Spring入门与扩展（3）_kubiex-spring-优快云博客

本文链接：https://blog.youkuaiyun.com/kubichengxuyuanz/article/details/102471058

本文详细介绍Spring与MyBatis的整合过程，包括如何配置DataSource、SqlSessionFactoryBean、MapperScannerConfigurer，以及事务控制的实现。同时，介绍了基于注解的整合方式，以及配置参数分离和与web集成的方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

#一、Spring-Mybatis整合

将Model层管理在工厂中，势必要将Service和DAO的对象纳入工厂，而Service和DAO中还依赖这Mybatis的相关封装功能，所以，只有将Mybatis的相关功能组件也纳入工厂，才可以让Service和DAO照常运作。

需要纳入工厂的Mybatis的相关功能组件有：

DataSource 负责管理数据库连接
SqlSessionFacotry Mybatis使用的核心组件
MapperScannerConfigurer 负责创建DAO实现 (Mapper)

1. DataSource

数据源，即连接池。

作用：减少请求执行过程中，创建数据库连接的时间消耗，提升执行性能。

常见连接池：dbcp，c3p0，durid

<!-- druid依赖 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.12</version>
</dependency>

<!-- dbcp依赖 -->
<dependency>
    <groupId>commons-dbcp</groupId>
    <artifactId>commons-dbcp</artifactId>
    <version>1.4</version>
</dependency>

<!-- c3p0依赖 -->
<dependency>
    <groupId>com.mchange</groupId>
    <artifactId>c3p0</artifactId>
    <version>0.9.5.2</version>
</dependency>

<!-- spring-jdbc(会传递tx) ，context-support ,aspects-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>4.3.6.RELEASE</version>
</dependency>

<!-- spring+mybatis集成依赖 -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>1.3.1</version>
</dependency>

<!-- 连接池：dbcp -->
<bean id="dbcp_pool" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
    <!-- 基本参数 -->
    <property name="url" value="jdbc:mysql://localhost:3306/db1?useUnicode=true&amp;characterEncoding=utf8"/>
    <property name="username" value="root"></property>
    <property name="password" value="111111"></property>
    <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
    <!-- 详细参数 -->
    <!-- 连接池的最大连接对象 数量 -->
    <property name="maxActive" value="3"></property>
    <!-- 最少要空闲 1 个连接对象 -->
    <property name="minIdle" value="1"></property>
    <!-- 初始化连接池  要创建1个连接对象 -->
    <property name="initialSize" value="1"></property>
    <!-- 当向连接池索要连接时，如果没有空闲连接，最大等待的时长：毫秒 -->
    <property name="maxWait" value="3000"></property>
</bean>

<!-- 连接池：druid -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" 
      destroy-method="close">
    <!-- 基本属性 url、user、password -->
    <property name="url" value="jdbc:mysql://localhost:3306/db1?useUnicode=true&amp;characterEncoding=utf8"/>
    <property name="username" value="root"/>
    <property name="password" value="111111"/>

    <!-- 配置初始化大小、最小、最大 -->
    <property name="initialSize" value="1"/>
    <property name="minIdle" value="1"/>
    <property name="maxActive" value="20"/>

    <!-- 配置获取连接等待超时的时间 -->
    <property name="maxWait" value="60000"/>

    <!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->
    <property name="timeBetweenEvictionRunsMillis" value="60000"/>

    <!-- 配置一个连接在池中最小空闲的时间，单位是毫秒 -->
    <property name="minEvictableIdleTimeMillis" value="300000"/>

    <property name="validationQuery" value="SELECT 'x'"/>
    <property name="testWhileIdle" value="true"/>
    <property name="testOnBorrow" value="false"/>
    <property name="testOnReturn" value="false"/>
</bean>

2. SqlSessionFactoryBean

是一个工厂bean，用于生产SqlSessionFactory.

依赖点：

datasource
dao映射文件位置
别名

<!-- 工厂bean：生成SqlSessionFactory -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <!-- 注入连接池 -->
    <property name="dataSource" ref="dataSource"></property>
    <!-- 注入dao-mapper文件信息 ,如果映射文件和dao接口 同包同名，则此配置可省略-->
    <property name="mapperLocations">
        <list>
            <value>classpath:com/zhj/dao/*.xml</value>
        </list>
    </property>
    <!-- 为 dao-mapper文件中的实体 定义缺省包路径 
		如：<select id="queryAll" resultType="User"> 中 User类可以不定义包
    -->
    <property name="typeAliasesPackage" value="com.zhj.domain"></property>
</bean>

3. MapperScannerConfigurer

<!-- mapperScannerConfigurer
		生产DAO实现类的对象，纳入工厂管理
		行为：
		  1.扫描所有DAO接口,去构建DAO实现
		  3.将DAO实现纳入工厂管理 且DAO实现对象在工厂中的id是：“首字母小写的-接口的类名”
                                                   UserDAO==userDAO  OrderDAO==orderDAO
-->
<bean id="mapperScannerConfigurer9" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
   	<!-- dao接口所在的包  如果有多个包，可以用逗号或分号分隔 
  		<property name="basePackage" value="com.a.dao,com.b.dao"></property>
   	-->
    <property name="basePackage" value="com.zhj.dao"></property>
    <!-- SqlSessionFacotry: *mapper文件  *SqlSession -->
    <!-- 如果工厂中只有一个SqlSessionFactory的bean，此配置可省略 -->
    <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>
</bean>

测试如下：

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
SqlSessionFactory factory = (SqlSessionFactory)context.getBean("sqlSessionFactory");
//获取SqlSession,其中会需要一个Connection
SqlSession session1 = factory.openSession();
session1.getConnection();
SqlSession session2 = factory.openSession();
session2.getConnection();
SqlSession session3 = factory.openSession();
session3.getConnection();
SqlSession session4 = factory.openSession();
session4.getConnection();
System.out.println("test----------");

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
//获取DAO对象
UserDAO ud = (UserDAO)context.getBean("userDAO");
List<User> users = ud.queryAll();
for(User user:users){
    System.out.println(user);
}
ud.insertUser(new User());//注意：此时事务是自动提交的

##4. 事务控制

4.1 DataSourceTransactionManager

事务管理器，其中持有DataSource，可以控制事务功能。

<!-- 1. 引入一个事务管理器，其中依赖DataSource,借以获得连接，进而控制事务逻辑 -->
<bean id="tx" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="druid_pool"></property>
</bean>

注意：DataSourceTransactionManager 和 SqlSessionFactoryBean 要注入同一个DataSource的Bean，否则事务控制失败!!!

###4.2 进一步定制

基于事务管理器，进一步定制，生成一个额外功能：Advice。

此Advice可以切入任何需要事务的方法，通过事务管理器为方法控制事务。

<tx:advice id="txManager" transaction-manager="tx">
	<tx:attributes>
		<!-- 如果 此事务管理可能切入此方法，则可以为此方法，单独定制事务属性 -->
		<!-- 以User结尾的方法
			<tx:method name="*User" rollback-for="Exception" isolation="DEFAULT"    
              	propagation="REQUIRED" read-only="false"/> 
		-->
        <!-- 以save开头的方法 -->
        <tx:method name="save*" rollback-for="Exception"/>
        <!-- 以query开头的方法 -->
        <tx:method name="query*" propagation="SUPPORTS"/>
        <!-- 剩余所有方法 -->
        <tx:method name="*"/>
    </tx:attributes>
</tx:advice>

4.3 编织

将事务管理的Advice 切入需要事务的业务方法中

<aop:config>
	<aop:pointcut expression="execution(* com.service.UserServiceImpl.*(..))" id="pc"/>
    <!-- 组织切面 -->
    <aop:advisor advice-ref="txManager" pointcut-ref="pc"/>
</aop:config>

###4.4 事务属性补充

1> isolation = 隔离级别 隔离级别由近到远，则并发性降低，安全性提高

default (默认值==采用数据库的默认的设置)
read-uncommited 读未提交
read-commited 读提交
repeatable-read 可重复读
serialized-read 序列化读

细节：

1> oracle只支持了读提交(默认) 和序列化读
2> mysql都支持了可重复读(默认)

事务并发时的安全问题：

1> 脏读：一个事务中读到了其他事务中未提交的数据
2> 不可重复读：一个事务中多次读取相同的数据行，但是，结果不一致
3> 幻影读：一个事务中多次读取同一张表，但是，数据行数不一致；
查询时没有某数据，但是操作时，却提示存在此数据。


 2.propagation=传播性
     support = 如果已经有事务，则融入这个事务；如果没事务，以非事务环境运行
     required = 如果已经有事务，则融入这个事务；如果没事务，开启自己的事务 (默认值)
   service1:fn1
   service2:fn2
 3.read-only:读写性
     true:只读事务，事务中只出现查询行为
     false：读写事务，事务中可以出现curd行为  （默认值）
 4.rollback-for:回滚时刻
 	1>如果事务中抛出 运行时异常(RuntimeException),则自动回滚
 	2>如果事务中抛出 已检查异常(非运行时异常 Exception)，不会自动回滚，而是默认提交事务
 	rollback-for="SQLException"
 	rollback-for="Exception"

##5. 更新丢失

5.1 概述

多事务并发，且存在多个事务更新相同数据时。

t_user

id name age

1 zhj 17

事务1： age+1

1> select age from t_user where id=1;

age=17;

3> update t_user set age = 18 where id=1;

commit;

age=18;

事务2：age+2

2> select age from t_user where id=1;

age=17;

4> update t_user set age = 19 where id=1;

commit;

age=19;

5.2 悲观锁 : for update

t_user

id name age

1 zhj 17

事务1： age+1

1> select age from t_user where id=1 for update;

age=17;

2> update t_user set age = 18 where id=1;

commit;

age=18;

事务2：age+2

3> select age from t_user where id=1 for update;

age=18;

4> update t_user set age = 20 where id=1;

commit;

age=20;

5.3 乐观锁 : version

t_user

id name age version

1 zhj 17 0

事务1： age+1

1> select age,version from t_user where id=1;

age=17; version=0

3> update t_user set age = 18,version=1 where id=1 and version=0;

commit;

age=18; version=1;

事务2：age+2

2> select age,version from t_user where id=1;

age=17; version=0

4> update t_user set age = 19,version=1 where id=1 and version=0;

commit;

未更新到任何行，重试即可

#二、基于注解整合

##1. 注解使用

@Service 业务类专用
@Repository dao实现类专用

@Controller web层专用

@Component 通用

@Scope 用户控制bean的创建模式

部分 <bean> 可以省略 !!

// @Service说明 此类是一个业务类，需要将此类纳入工厂==bean  等价替换掉 <bean class="xxx.UserServiceImpl">
// @Service默认beanId == 首字母小写的类名"userServiceImpl"
// @Service("userService") 自定义beanId为"userService"
@Service
public class UserServiceImpl implements UserService {
 	...   
}

@Autowired 基于类型自动注入
@Resource 基于名称自动注入

更便捷的注入方式 !!

public class UserServiceImpl implements UserService {
	...
	//@Resource(name="userService9")//将id=userService9的bean注入给此属性
	//此属性要求工厂，基于名称自动注入
	//@Resource //set/get可省略
	//此属性要求工厂，基于类型自动注入
	@Autowired //set/get可省略
	private UserDao userDao;
	...
}

@Transactional 用于为业务中切入事务

工厂配置中的 <tx:advice… 和 <aop:config… 可以省略 !!

//类中的每个方法都切入事务(有自己的事务控制的方法除外)
@Transactional(isolation=Isolation.READ_COMMITTED,propagation=Propagation.REQUIRED,readOnly=false,rollbackFor=Exception.class)
public class UserServiceImpl implements UserService {
	...
    //该方法自己的事务控制，仅对此方法有效
	@Transactional(propagation=Propagation.SUPPORTS)
	public List<User> queryAll() {
		return userDao.queryAll();
	}
	public void save(User user){
		userDao.save(user);
	}
}

##2. 注解需要的配置

<!-- 告知spring，哪些包中 有被注解的类、方法、属性 -->
<!-- <context:component-scan base-package="com.zhj.action,com.zhj.service"></context:component-scan> -->
<context:component-scan base-package="com.zhj"></context:component-scan>
	
<!-- 告知spring，@Transactional在定制事务时，基于txManager=DataSourceTransactionManager -->
<tx:annotation-driven transaction-manager="txManager"/>

3. @AspectJ

@Aspect // AspectJ的注解
@Component
@Order(1) //执行顺序，如果有两个 Aspect，都切了相同的点，则可以区分顺序
public class MyAspect {
    @Pointcut("execution(* com.zhj.service.UserServiceImpl.*(..))")
    public void pc(){}
    @Before("pc()") // AspectJ的注解
    public void beforezhj(JoinPoint a) {
        System.out.println("target:"+a.getTarget());
        System.out.println("args:"+a.getArgs());
        System.out.println("method's name:"+a.getSignature().getName());
        System.out.println("before~~~~");
    }

    @AfterReturning(value="pc()",returning="ret9") // AspectJ的注解
    public void myAfterReturning(JoinPoint a,Object ret9){
        System.out.println("after~~~~:"+ret9);
    }
    @Around("pc()") // AspectJ的注解
    public Object myInterceptor(ProceedingJoinPoint p) throws Throwable {
        System.out.println("interceptor1~~~~");
        Object ret = p.proceed();
        System.out.println("interceptor2~~~~");
        return ret;
    }
    @AfterThrowing(value="pc()",throwing="ex") // AspectJ的注解
    public void myThrows(JoinPoint jp,Exception ex){
        System.out.println("throws");
        System.out.println("===="+ex.getMessage());
    }
}

<!-- 添加如下配置 -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
<context:component-scan base-package="com.zhj"/>

#三、配置参数分离

1.定义参数文件

c9.url=jdbc:mysql://localhost:3306/db1?useUnicode=true&amp;characterEncoding=utf8
c9.username=root
c9.password=111111
c9.maxActive=3

2.在工厂配置中导入外部文件

<!-- 导入外部的配置信息 -->
<context:property-placeholder location="classpath:db.properties"/>

##3.在工厂配置中使用外部参数

${xxxx}

<property name="url" value="${c9.url}"></property>
<property name="username" value="${c9.username}"></property>
<property name="password" value="${c9.password}"></property>
<property name="maxActive" value="${c9.maxActive}"></property>

四、与web集成

4.1 ContextLoaderListener

核心：注册ContextLoaderListener

<!-- 提供和web环境集成的支持 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>4.3.6.RELEASE</version>
</dependency>

<!-- 监听项目的启动，负责启动spring工厂，并把工厂对象存储于ServletContext作用域中
    细节：需要知道 spring的配置文件的位置。会从 一个名为"contextConfigLocation"的context-param中获取
  -->
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- 定义了spring配置文件位置 -->
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
</context-param>

4.2 Servlet集成工厂

public class UserServlet extends HttpServlet {
    // 获取项目启动时随之启动的，存储于ServletContext中的工厂对象，
    private ApplicationContext context = ContextLoader.getCurrentWebApplicationContext();
    // 从工厂中获取Service组件
    private UserService userService = context.getBean("userService",UserService.class);
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws 
        ServletException, IOException {
        List<User> users = userService.queryUsers();
        req.setAttribute("users",users);
        req.getRequestDispatcher("/users.jsp").forward(req,resp);
    }
}