6、使用注解开发
在Spring4之后 要使用注解开发必须得要导入aop的包导入
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DuHfLI8R-1666229822693)(C:\Users\28280\AppData\Roaming\Typora\typora-user-images\image-20221005214208590.png)]
使用注解需要导入Context约束,增加注解的支持!
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<!--开启注解支持-->
<context:annotation-config/>
</beans>
-
bean
-
属性如何注入
//等价于 <bean id="user" class="com.oy.pojo.User"> //@Component 组件 @Component public class User { //相当于:<property name="name" value="欧阳"/> @Value("欧阳") public String name; }
-
衍生的注解
@Component有几个衍生注解,我们在web开发中,会按照mvc三层架构分层
-
dao【@Repository】
-
service 【@Service】
-
controller【@Controller】
这四个注解功能都是一样的,都是代表将某个类注册到Spring某个容器中,装配Bean
-
-
自动装配
@Autowired:自动装配通过类型名字 如果AutoWired不能唯一自动装配上属性,则需要通过@Qualifier(value="xxx") @Nullable 字段标记了这个注解,说明这个字段可以为null @Resource 自动装配通过名字,类型
-
作用域
@Component @Scope("singleton") //配置单例或者原型 public class User { //相当于:<property name="name" value="欧阳"/> @Value("欧阳") public String name; }
-
小结
xml与注解
- xml更加万能,适用于任何场合! 维护方便简单
- 注解 不是自己类用不了,维护相对复杂!
xml与注解最佳实践:
- xml用来管理bean;
- 注解只负责完成属性的注入
- 我们在使用的过程中,只需要注意一个问题,必须让注解生效:就需要开启注解的支持
<!--开启注解支持--> <context:annotation-config/> <!--指定要扫码的包,这个包下的注解就会生效--> <context:component-scan base-package="com.oy.pojo" />
2.5、完全使用Java的方式配置Spring
我们现在要完全不使用Spring的xml配置了,全权交给Java来做
JavaConfig是Spring的一个子项目,在Spring 4 之后,他成为了一个核心功能!
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aG7MzOBJ-1666229822695)(C:\Users\28280\AppData\Roaming\Typora\typora-user-images\image-20221005231844447.png)]
实体类
package com.oy.pojo;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;
//这里这个注解的意思;就是说明这个类被Spring接管了,注册到容器中
@Component
public class User {
private String name;
public String getName() {
return name;
}
@Value("张三") //属性注入值
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
'}';
}
}
配置文件
import com.oy.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
//这个也会被Spring容器托管,注册到容器中,因为他本来就是一个@Component
//@Configuration代表这是一个配置类,就和我们之前看的beans.xml一样
@Configuration
@ComponentScan("com.oy.pojo")
@Import(myConfig2.class) //引入另一个类中实现的bean
public class myConfig {
//注册一个bean:相当于我们之前写的一个bean标签
//这个方法的名字,就相当于bean标签中的id属性
//这个方法的返回值,相当于bean标签中的class属性
@Bean
public User User(){
return new User(); //就是返回要注入到bean的对象
}
}
测试类
import com.oy.config.myConfig;
import com.oy.pojo.User;
import com.sun.org.apache.bcel.internal.generic.NEW;
import javafx.application.Application;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class myTest {
public static void main(String[] args) {
//如果完全使用了配置类的方式去做,我们就只能通过 AnnotationConfig 上下文来获取容器,通过配置类的class对象加载!
ApplicationContext context = new AnnotationConfigApplicationContext(myConfig.class);
User getUser = (User) context.getBean("User");
System.out.println(getUser.getName());
}
}
这种纯Java的配置方式,在SpringBoot中随处可见!
7、代理模式
为什么要学习代理模式? 因为这就是Spring Aop的底层!【SpringAOP和SpringMVC】
代理模式的分类:
- 静态代理
- 动态代理
- [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wVG8NMVd-1666229822696)(C:\Users\28280\AppData\Roaming\Typora\typora-user-images\image-20221006210538884.png)]
7.1、静态代理
角色分析:
- 抽象角色:一般会使用接口或者抽象类来解决
- 真实角色:被代理的角色
- 代理角色:代理真实角色,代理真实角色后,我们一般会做一些附属操作
- 客户:访问代理对象的人!
代码步骤:
-
接口
//租房子 public interface Ren { public void ren(); }
-
真实角色
//房东 public class Host implements Ren{ @Override public void ren() { System.out.println("房东出租房子"); } }
-
代理角色
package com.oy.demo01; public class person implements Ren{ private Host host; public person() { } public person(Host host) { this.host = host; } @Override public void ren() { host.ren(); seeHost(); getMoney(); } //看房 public void seeHost(){ System.out.println("中介带看房子"); } //收取中介费 public void getMoney(){ System.out.println("中介收取中介费"); } }
-
客户端访问代理角色
package com.oy.demo01; public class my { public static void main(String[] args) { //房东出租房子 Host host=new Host(); //代理 中介代房东出租房子 但是一般中介会有一些附属操作 person person=new person(host); //不用面向房东 直接找中介 person.ren(); } }
代理模式的好处:
- 可以使真实角色的操作更加纯粹!不用去关注一些公共业务
- 公共也就是交给代理角色,实现了业务的分工
- 公共业务发生扩展的时候,方便集中管理
缺点:
- 一个真实角色就会产生一个代理角色,代码量会翻倍开发效率会变低
7.2、加深理解
聊聊AOP
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fWoFOjtT-1666229822697)(C:\Users\28280\AppData\Roaming\Typora\typora-user-images\image-20221006233745072.png)]
7.3、动态代理
- 动态代理和静态代理角色一样
- 动态代理的代理类是动态生成的,不是 我们直接写好的
- 动态代理分为两大类:基于接口的动态代理,基于类的动态代理
- 基于接口-----JDK动态代理配【我们在这里使用】
- 基于类:cglib
- java字节码实现:javasist
需要了解两个类:Proxy:代理,InvocationHandler:调用处理程序
InvocationHandler
动态代理的好处:
- 可以使真实角色的操作更加纯粹!不用去关注一些公共业务
- 公共也就是交给代理角色,实现了业务的分工
- 公共业务发生扩展的时候,方便集中管理
- 一个动态代理类代理的是一个接口,一般也就是一类业务
- 一个动态代理类可以代理多个类,只要是实现了同一个接口即可
8、什么是Aop
AOP:Aspect Oriented Programming,面向切面编程。
通过预编译和运行期动态代理实现程序功能的统一维护。
在Spring框架中,AOP就是一个很重要的功能。
AOP 利用一种称为横切的技术,剖开对象的封装,并将影响多个类的公共行为封装到一个可重用模块,组成一个切面,即 Aspect 。
"切面"就是将那些与业务无关,却为业务模块所共同调用的逻辑或责任封装起来,便于减少系统的重复代码,降低模块间的耦合度,利于可操作性和可维护性。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YsB8sucl-1666229822698)(C:\Users\28280\AppData\Roaming\Typora\typora-user-images\image-20221008213032108.png)]
8.1、Aop在Spring中的作用
提供声明式事务:允许用户自定义切面
- 横切关注点:跨越应用程序多个模块的方法或功能,即是,与我们业务逻辑无关的,但是我们需要关注的部分,就是横切关注点,如日志,安全 ,缓存,事务等等
- 切面(ASPECT):横切关注点被模块化的特殊对象,即,他是一个类
- 通知(ASPECT):切面必须要完成的工作,即,他是类中的一个方法
- 目标(Target):被通知对象
- 代理(Proxy):向目标对象应用通知之后创建的对象
- 切入点(PointCut):切面通知执行的地点的定义、
- 连接点(JoinPoint):与切入点匹配的执行点
- [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-V98k2gVl-1666229822698)(C:\Users\28280\AppData\Roaming\Typora\typora-user-images\image-20221008214250062.png)]
8.2、使用Spring实现Aop
[重点]使用AOP注入,需要导入一个依赖包
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.9.1</version>
</dependency>
</dependencies>
方式一:使用Spring的api接口【主要是SpringAPI接口实现】
接口:
package com.oy.service;
public interface UserService {
public void add();
public void select();
public void delete();
public void update();
}
实现类:
package com.oy.service;
public class UserServiceImp implements UserService {
@Override
public void add() {
System.out.println("添加了一个用户");
}
@Override
public void select() {
System.out.println("查询了一个用户");
}
@Override
public void delete() {
System.out.println("删除了一个用户");
}
@Override
public void update() {
System.out.println("修改了一个用户");
}
}
日志类:
package com.oy.log;
import org.springframework.aop.AfterReturningAdvice;
import java.lang.reflect.Method;
public class AfterLog implements AfterReturningAdvice {
//returnValue :返回值
public void afterReturning(Object returnValue, Method method, Object[] objects, Object o1) throws Throwable {
System.out.println("执行了"+method.getName()+"返回结果为"+returnValue);
}
}
日志类2
package com.oy.log;
import org.springframework.aop.MethodBeforeAdvice;
import java.lang.reflect.Method;
public class log implements MethodBeforeAdvice {
//method:要执行的目标对象的方法
//objects :参数
//target:目标对象
public void before(Method method, Object[] args, Object target) throws Throwable {
System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了");
}
}
配置文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<!--注册bean-->
<bean id="userService" class="com.oy.service.UserServiceImp"/>
<bean id="log" class="com.oy.log.log"/>
<bean id="afterLog" class="com.oy.log.AfterLog"/>
<!--方式一,使用原生SpringApi接口-->
<!--配置Aop 需要导入aop的约束-->
<aop:config>
<!-- 切入点 expression:表达式:expression(要执行的位置! * * * *)-->
<aop:pointcut id="pointcut" expression="execution(* com.oy.service.UserServiceImp.*(..))"/>
<!-- 执行环绕增强!-->
<aop:advisor advice-ref="log" pointcut-ref="pointcut" />
<aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
</aop:config>
</beans>
测试类:
import com.oy.service.UserService;
import com.oy.service.UserServiceImp;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("SpringApp.xml");
//动态代理代理的是接口 注意点
UserService userService = (UserService) context.getBean("userService");
userService.add();
}
}
方法二:自定义来实现AOP【主要是切面定义】
<!-- 方式二-->
<bean id="diy" class="com.oy.diy.DiyPointCut"/>
<aop:config>
<!-- 自定义切面:ref要引用的类-->
<aop:aspect ref="diy">
<!--切入点-->
<aop:pointcut id="point" expression="execution(* com.oy.service.UserServiceImp.*(..))"/>
<!-- 通知 设置执行地方-->
<aop:before method="before" pointcut-ref="point"/>
<aop:after method="after" pointcut-ref="point"/>
</aop:aspect>
</aop:config>
</beans>
方式三:使用注解实现:
<!-- 方式三-->
<bean id="annotationPointCut" class="com.oy.diy.AnnotationPontCut"/>
<aop:aspectj-autoproxy/>
新增加类
package com.oy.diy;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
@Aspect//标注这个类是一个切面
public class AnnotationPontCut {
@Before("execution(* com.oy.service.UserServiceImp.*(..))")
public void before(){
System.out.println("======方法执行前======");
}
}
9、整合Mybatis
步骤:
- 导入相关jar包
- junit
- mybatis
- mysql数据库
- Spring相关的
- aop植入
- mybatis-spring【new】
- 编写配置文件
- 测试
9.1、回忆mybatis
-
导入配置文件
<dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.13</version> <scope>test</scope> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.47</version> </dependency> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.2</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>5.1.9.RELEASE</version> </dependency> <!-- spring操作数据库的话,还需要一个spring-jdb--> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>5.1.9.RELEASE</version> </dependency> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis-spring</artifactId> <version>2.0.2</version> </dependency> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.9.9.1</version> </dependency> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <version>1.18.24</version> </dependency> </dependencies> <build> <resources> <resource> <directory>src/main/java</directory> <includes> <include>**/*.xml</include> </includes> <filtering>true</filtering> </resource> </resources> </build>
-
编写实体类
package com.oy.pojo; import lombok.Data; @Data public class User { private int id; private String name; private String pwd; }
-
编写核心配置文件
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd"> <!--configuration 核心配置文件--> <configuration> <!--别名 --> <typeAliases> <package name="com.oy.pojo"/> </typeAliases> <!-- 环境模式:development开发模式 work工作模式 --> <environments default="development"> <!--环境变量 --> <environment id="development"> <!--事务管理器 --> <transactionManager type="JDBC" /> <!--数据源 --> <dataSource type="POOLED"> <property name="driver" value="com.mysql.jdbc.Driver"/> <property name="url" value="jdbc:mysql://localhost:3306/data?useSSL=true"/> <property name="username" value="root"/> <property name="password" value="1234"/> </dataSource> </environment> </environments> <mappers> <mapper class="com.oy.mapper.UserMapper"/> </mappers> </configuration>
-
编写接口
package com.oy.mapper; import com.oy.pojo.User; import java.util.List; public interface UserMapper { public List<User> SelectUser(); }
-
编写mapper.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.oy.mapper.UserMapper"> <select id="SelectUser" resultType="User"> select *from User; </select> </mapper>
-
编写测试
import com.oy.mapper.UserMapper; import com.oy.pojo.User; import org.apache.ibatis.io.Resources; import org.apache.ibatis.session.SqlSession; import org.apache.ibatis.session.SqlSessionFactory; import org.apache.ibatis.session.SqlSessionFactoryBuilder; import org.junit.Test; import java.io.IOException; import java.io.InputStream; import java.util.List; public class MyTest { @Test public void test() throws IOException { String resources="mybatis-config.xml"; InputStream in = Resources.getResourceAsStream(resources); SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(in); SqlSession sqlSession = sqlSessionFactory.openSession(true); UserMapper mapper = sqlSession.getMapper(UserMapper.class); List<User> userList=mapper.SelectUser(); for (User user: userList) { System.out.println(user); } } }
-
编写数据库
create database data; use data; create table User( id int, username varchar(50), pwd varchar(55) ); insert into User values (1,'欧阳','1234'); insert into User values (2,'张三','6666'); insert into User values (3,'李四','8888'); insert into User values (4,'王五','99999');
9.2、MyBatis-Spring[重点]
- 编写数据源
- sqlSessionFactory
- sqlSessionTemplate
- 需要给接口加实现类【】
- 将自己写的实现类,注入到Spring
- 测试
- 较Mybatis不同 处
spring-dao.xml
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <!-- DataSource:使用Spring的数据源替换MyBatis的配置 c3p0 dbcp druid 我们这里使用Spring提供的JDBC --> <bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"> <property name="driverClassName" value="com.mysql.jdbc.Driver"/> <property name="url" value="jdbc:mysql://localhost:3306/data?useSSL=true"/> <property name="username" value="root"/> <property name="password" value="1234"/> </bean> <!-- SqlSessionFactory--> <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> <property name="dataSource" ref="datasource"/> <!-- 绑定 mybatis配置文件 --> <property name="configLocation" value="classpath:mybatis-config.xml"/> <property name="mapperLocations" value="classpath:com/oy/mapper/*.xml"/> </bean> <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate"> <!-- 只能使用构造器注入sqlSessionFactory,因为它没有set方法--> <constructor-arg index="0" ref="sqlSessionFactory"/> </bean> <!-- --> <bean id="userMapper" class="com.oy.mapper.UserMapperImpl"> <property name="sqlSession" ref="sqlSession"/> </bean> </beans>
实现类
package com.oy.mapper; import com.oy.pojo.User; import org.mybatis.spring.SqlSessionTemplate; import java.util.List; public class UserMapperImpl implements UserMapper { //我们的所有操作,在原来都使用sqlSession来执行,现在都使用SqlSessionTemplate private SqlSessionTemplate sqlSession; public void setSqlSession(SqlSessionTemplate sqlSession) { this.sqlSession = sqlSession; } public List<User> SelectUser() { UserMapper mapper = sqlSession.getMapper(UserMapper.class); return mapper.SelectUser(); } }
测试类
import com.oy.mapper.UserMapper; import com.oy.pojo.User; import org.apache.ibatis.io.Resources; import org.apache.ibatis.session.SqlSession; import org.apache.ibatis.session.SqlSessionFactory; import org.apache.ibatis.session.SqlSessionFactoryBuilder; import org.junit.Test; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; import java.io.IOException; import java.io.InputStream; import java.util.List; public class MyTest { @Test public void test() throws IOException { ApplicationContext context = new ClassPathXmlApplicationContext("Spring-dao.xml"); UserMapper userMapper = context.getBean("userMapper", UserMapper.class); for (User user : userMapper.SelectUser()) { System.out.println(user); } } }
-
9.3、SqlSessionDaoSupport
与上述改变之处
spring-dao.xml
<!--添加一个bean-->
<bean id="userMapperTo" class="com.oy.mapper.UserMapperImplTo">
<property name="sqlSessionFactory" ref="sqlSessionFactory"/>
</bean>
实现类
package com.oy.mapper;
import com.oy.pojo.User;
import org.mybatis.spring.support.SqlSessionDaoSupport;
import java.util.List;
public class UserMapperImplTo extends SqlSessionDaoSupport implements UserMapper{
@Override
public List<User> SelectUser() {
return getSqlSession().getMapper(UserMapper.class).SelectUser();
}
}
10、声明式事务
1、回顾事务
- 把一组业务当成一个业务来做:要么都成功,要么都失败
- 事务在项目开发中,十分重要,涉及到数据的一致性问题,不能马虎
- 确保完整性和一致性
事务的ACID原则
- 原子性
- 一致性
- 隔离性
- 多个业务可能操作同一个资源,防止数据损坏
- 持久性
- 事务一旦提交,无论系统发生什么问题,结果都不回被影响,被持久化的写到存储器中
2、Spring中的事务管理器
- 声明式事务:Aop横切进去
- 编程式事务:需要在代码中,进行事务的管理
思考:
为什么需要事务?
- 如果不配置事务,可能存在数据提交不一致的情况下;
- 如果我们不在spring 中去配置声明式事务,我们就需要在代码中手动配置事务
- 事务在项目的开发中十分重要,设计到数据的一致性和完整性问题,不容马虎!
代码:
需求;在故意写错删除sql语法时 同时执行查询插入修改,保证报错的前提下插入不成功,需要借住事务管理器完成
User:
package com.oy.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
//有参构造
@AllArgsConstructor
//无参构造
@NoArgsConstructor
public class User {
private int id;
private String name;
private String pwd;
}
UserMapper:接口
package com.oy.mapper;
import com.oy.pojo.User;
import java.util.List;
public interface UserMapper {
public List<User> SelectUser();
//添加一个用户
public int addUser(User user);
//删除一个用户
public int deleteUser(int id);
}
UserMapperImpl:实现类
package com.oy.mapper;
import com.oy.pojo.User;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.support.SqlSessionDaoSupport;
import java.util.List;
public class UserMapperImpl extends SqlSessionDaoSupport implements UserMapper {
public List<User> SelectUser() {
User user= new User(5,"小王","12345");
UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
mapper.addUser(user);
mapper.deleteUser(4);
return mapper.SelectUser();
}
@Override
public int addUser(User user) {
return getSqlSession().getMapper(UserMapper.class).addUser(user);
}
@Override
public int deleteUser(int id) {
return getSqlSession().getMapper(UserMapper.class).deleteUser(id);
}
}
UserMapper.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.oy.mapper.UserMapper">
<select id="SelectUser" resultType="User">
select *from User;
</select>
<insert id="addUser" parameterType="user">
insert into User(id,name,pwd ) value (#{id},#{name},#{pwd});
</insert>
<delete id="deleteUser" parameterType="int">
<!--故意写错delete -->
deletes from User where id=#{id};
</delete>
</mapper>
Application.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<import resource="Spring-dao.xml"/>
<bean id="UserMapper" class="com.oy.mapper.UserMapperImpl">
<property name="sqlSessionFactory" ref="sqlSessionFactory"/>
</bean>
</beans>
Spring-dao.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- DataSource:使用Spring的数据源替换MyBatis的配置 c3p0 dbcp druid
我们这里使用Spring提供的JDBC
-->
<bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/data?useSSL=true"/>
<property name="username" value="root"/>
<property name="password" value="1234"/>
</bean>
<!-- SqlSessionFactory-->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="datasource"/>
<!-- 绑定 mybatis配置文件 -->
<property name="configLocation" value="classpath:mybatis-config.xml"/>
<property name="mapperLocations" value="classpath:com/oy/mapper/*.xml"/>
</bean>
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
<!-- 只能使用构造器注入sqlSessionFactory,因为它没有set方法-->
<constructor-arg index="0" ref="sqlSessionFactory"/>
</bean>
<!--配置声明式事务-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="datasource"/>
</bean>
<!--结合Aop实现事务的植入 事务管理器:唯一的Spring提供的:transaction-manager="transactionManager"-->
<!-- 配置事务通知:-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<!-- 给哪些方法配置事务-->
<!-- 配置事务的传播特效:propagation默认REQUIRED:代表支持事务-->
<tx:attributes>
<tx:method name="add" propagation="REQUIRED"/>
<tx:method name="delete" propagation="REQUIRED"/>
<tx:method name="select" propagation="REQUIRED"/>
<!-- read-only="true:只读 -->
<tx:method name="query" read-only="true"/>
<!-- *代表所以方法-->
<tx:method name="*" propagation="REQUIRED"/>
</tx:attributes>
</tx:advice>
<!-- 配置事务切入-->
<aop:config>
<!-- id随便起名字-->
<aop:pointcut id="txPointCut" expression="execution(* com.oy.mapper.*.*(..))"/>
<!-- 把事务:txAdvice切进去 切入到txPointCut:也就是Mapper下面的所以类的所以方法 -->
<aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
</aop:config>
</beans>
借鉴于狂神说java 仅供笔记回顾 如看详细可以查狂神说java