1. Spring
1.1 简介
- Spring：给软件行业带来了春天
- 2002年 首次推出了Spring框架的雏形：interface框架
- 2004年 Spring框架以interface21为框架推出了正式的1.0版本
- Spring理念：使现有的技术更加容易使用，本身是一个大杂烩，整合了现有的技术框架
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.3.6</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.3.6</version>
</dependency>
1.2 优点
- Spring是一个开源的免费的框架（容器）
- Spring是一个轻量级、非入侵式的框架
- 控制翻转（IOC） 面向切面编程（AOP）
- 支持事务处理 对框架整合的支持
总结：Spring就是一个轻量级的控制反转（IOC） 和 面向切面编程（AOP）的框架
1.3 组成
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4ycyCLdo-1623317000717)(G:\vscode_files\blog\Spring.assets\20170713150400373)]
1.4 拓展
现代化的Java开发 说白了就是基于Spring的开发。
-
Spring Boot
- 一个快速开发的脚手架
-
基于SpringBoot可以快速的开发单个微服务
- 约定大于配置
-
Spirng Cloud
- 是基于spring boot实现的
弊端：发展了太久以后，违背了原来的理念，配置十分繁琐，人称“配置低于”
2.IOC理论推导
IOC本质
控制反转IoC(Inversion of Control)，是一种设计思想，DI(依赖注入)是实现IoC的一种方法，也有人认为DI只是IoC的另一种说法。没有IoC的程序中 , 我们使用面向对象编程 , 对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是：获得依赖对象的方式反转了。
采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。
控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection,DI）。
3.HelloSpring
<?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">
<!--bean就是java对象 , 由Spring创建和管理-->
<bean id="hello" class="com.fan.pojo.Hello">
<property name="str" value="Hello Spring"/>
</bean>
</beans>
@Test
public void test(){
//获取spring的上下文对象
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
//我们的对象现在都在spring中管理了 我们要使用“.”直接去里面取出来即可
Hello hello = (Hello) context.getBean("hello");
System.out.println(hello.toString());
}
思考问题 ?
Hello 对象是谁创建的 ?
hello 对象是由Spring创建的
Hello 对象的属性是怎么设置的 ?
hello 对象的属性是由Spring容器设置的 ,
这个过程就叫控制反转 :
控制 : 谁来控制对象的创建 , 传统应用程序的对象是由程序本身控制创建的 , 使用Spring后 , 对象是由Spring来创建的 .
反转 : 程序本身不创建对象 , 而变成被动的接收对象 .
依赖注入 : 就是利用set方法来进行注入的.
IOC是一种编程思想 , 由主动的编程变成被动的接收 .
可以通过newClassPathXmlApplicationContext去浏览一下底层源码 .
OK , 到了现在 , 我们彻底不用再程序中去改动了 , 要实现不同的操作 , 只需要在xml配置文件中进行修改 , 所谓的IoC,一句话搞定 : 对象由Spring 来创建 , 管理 , 装配 !
4.IOC创建对象的方式
- 使用无参构造创建对象 默认！
- 使用有参构造创建对象
- 下标赋值
<constructor-arg index="0" value="狂神说Java" - 直接通过参数名
<constructor-arg name="name" value="狂神说Java"
- 下标赋值
总结：在配置文件加载的时候，容器中管理的对象就已经初始化了。
5.Spring配置
5.1 别名
<alias name = "user" alias = "userNew"/>
这个没啥用，一般不用
5.2 Bean的配置
<bean id = "userT" class = "com.kuang.pojo.UserT" name = "user2 u2, u3; u4">
<property name = "name" value = "西部开源"/>w
</bean>
5.3 import
这个import一般用于团队开发使用，他可以将多个配置文件合并为一个
6. DI依赖注入
6.1 构造器注入
前面已经说过了
6.2 Set方式注入【重点】
- 依赖注入：Set注入
- 依赖：bean对象的创建依赖于容器
- 注入：bean对象中的所有属性 由容器来注入
【环境搭建】
- 复杂类型
package com.fan.pojo;
import java.util.*;
public class Student {
private String name;
private Address address;
private String[] books;
private List<String> hobbys;
private Map<String,String> card;
private Set<String> games;
private Properties info;
private String wife;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Address getAddress() {
return address;
}
public void setAddress(Address address) {
this.address = address;
}
public String[] getBooks() {
return books;
}
public void setBooks(String[] books) {
this.books = books;
}
public List<String> getHobbys() {
return hobbys;
}
public void setHobbys(List<String> hobbys) {
this.hobbys = hobbys;
}
public Map<String, String> getCard() {
return card;
}
public void setCard(Map<String, String> card) {
this.card = card;
}
public Set<String> getGames() {
return games;
}
public void setGames(Set<String> games) {
this.games = games;
}
public Properties getInfo() {
return info;
}
public void setInfo(Properties info) {
this.info = info;
}
public String getWife() {
return wife;
}
public void setWife(String wife) {
this.wife = wife;
}
@Override
public String toString() {
return new StringJoiner(", ", Student.class.getSimpleName() + "[", "]")
.add("name='" + name + "'")
.add("address=" + address.toString())
.add("books=" + Arrays.toString(books))
.add("hobbys=" + hobbys)
.add("card=" + card)
.add("games=" + games)
.add("info=" + info)
.add("wife='" + wife + "'")
.toString();
}
}
package com.fan.pojo;
import java.util.StringJoiner;
public class Address {
private String address;
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return new StringJoiner(", ", Address.class.getSimpleName() + "[", "]")
.add("address='" + address + "'")
.toString();
}
}
-
真实测试对象
-
<?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"> <bean id="address" class="com.fan.pojo.Address"> <property name="address" value="西安"/> </bean> <bean id = "student" class="com.fan.pojo.Student"> <!-- 第一种，普通值注入，value适用于基本值 --> <property name="name" value="秦疆"/> <!-- 第二种，Bean注入，ref 适用于引用对象 --> <property name="address" ref = "address"/> <property name="books"> <!-- 数组 --> <array> <value>红楼梦</value> <value>西游记</value> <value>水浒传</value> <value>三国演义</value> </array> </property> <property name="hobbys"> <list> <value>听歌</value> <value>敲代码</value> <value>看电影</value> </list> </property> <property name="card"> <map> <entry key="身份证" value="111111111111111111"/> <entry key="银行卡" value="22222222222222222222"/> </map> </property> <property name="games"> <set> <value>LOL</value> <value>DOTA2</value> </set> </property> <property name="wife"> <null></null> </property> <property name="info"> <props> <prop key="学号">151144101</prop> <prop key="性别">男</prop> <prop key="名字">小明</prop> </props> </property> </bean> </beans> -
测试
public class Mytest {
@Test
public void test(){
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
Student student = (Student) context.getBean("student");
System.out.println(student.toString());
}
}
6.3 拓展方式注入
p-namespace/c-namespace
<!-- p命名空间注入，可以直接注入属性的值：property-->
<bean id = "user" class = "com.fan.pojo.User" p:name="秦疆" p:age="18"/>
<!-- c命名空间注入,通过构造器注入：construct-args-->
<bean id = "user2" class = "com.fan.pojo.User" c:name="秦疆" c:age="18"/>
注意：p命名和c命名空间不能直接使用，需要导入xml约束！
xmlns:c="http://www.springframework.org/schema/c"
xmlns:p="http://www.springframework.org/schema/p"
6.4 bean的作用域
<!--1.单例模式-->
<bean id = "user2" class = "com.fan.pojo.User" c:name="秦疆" c:age="18"
scope = "singleton"/>
<!--2.原型模式:每次从容器中get的时候，都会产生一个新的对象-->
<bean id = "user2" class = "com.fan.pojo.User" c:name="秦疆" c:age="18"
scope = "prototype"/>
还有request、session、application这些只能在web开发中使用
7.bean的自动装配
- 自动装配是Spring满足bean依赖一种方式
- Spring会在上下文中自动寻找，并自动给bean装配属性
在spring中有三种装配方式
- 在xml中显示的配置
- 在java中显示配置
- 隐式的自动装配bean【重要】
7.1 测试
环境：一个人有两个宠物
7.2 自动装配
<?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">
<bean id="cat" class="com.fan.pojo.Cat"/>
<bean id="dog" class="com.fan.pojo.Dog"/>
<bean id="people" class="com.fan.pojo.People" autowire="byType">
<property name="name" value="小狂神呀"/>
</bean>
</beans>
小结：
- byname的时候，需要保证所有bean的id唯一，并且这个bean需要和自动注入的属性的set方法的值一致
- bytype的时候，需要保证所有bean的class唯一，并且这个bean需要和自动注入的属性的类型一致
7.3 使用注解实现自动装配
Jdk1.5支持的注解，Spring2.5就支持注解了
The inroduction of annotation-based configuration raised the question of whether this approach is “better” than XML.
要使用注解须知：
-
导入约束
-
配置注解的支持
<context:component-scan base-package="com.fan"/> <context:annotation-config/>
@Autowired
直接在属性上使用即可！也可以在set方式上使用！
使用Autowired我们可以不用编写set方法了，前提是你这个自动装配的属性在IOC（Spring)容器中存在，且符合名字byname!
科普：
@Nullable 字段标记了这个注解，说明这个字段可以为null;
public class People {
private String name;
@Autowired(required = false)
private Cat cat;
@Autowired
private Dog dog;
}
如果@Autowired自动装配的环境比较复杂，自动装配无法通过一个注解【@Autowired】完成的时候，我们可以使用@Qualifier(value = “xxx”)去配置@Autowired的使用，指定一个唯一的bean对象注入
@Resource注解
public class People {
@Resource(name = "cat2")
private Cat cat;
@Resource
private Dog dog;
}
小结
区别：
- 都是用来自动装配的 都可以放在属性字段上
- @autowired通过byType的方式实现，而且必须要求这个对象存在！【常用】
- @resource 默认通过byname方式实现，如果找不到名字，则通过byType实现！如果两个都找不到的情况下，就报错！
- 执行顺序不同
8. 使用注解开发
8.1 bean
8.2 属性如何注入
@Component
public class User {
@Value("狂神")
public String name;
}
8.3 衍生的注解
@Component 有几个衍生注解，我们在web开发中，会按照mvc三层架构分层！
- dao【@Repository】
- service【@Service】
- controller【@@Controller】
- 这四个注解功能都是一样的，都是代表将某个类注册到Spring中 装配Bean
8.4 自动装配
- @Autowired:自动装配 通过类型 名字
如果Autowired不能唯一自动装配上属性，则需要通过@Qualifier(value = "xxx")
- @Nullable 字段标记了这个注解，说明这个字段可以为null
- @Resource 自动装配通过名字 类型
8.5 作用域
@Scope("prototype")
8.6 小结
xml与注解：
- xml更加万能，适用于任何场合！维护简单方便
- 注解 不是自己的类用不了，维护相对复杂
- xml用来管理bean
- 注解只负责属性的注入
- 我们在使用的过程中 只需要注意一个问题：必须让注解生效，就需要开启注解的支持
9.使用Javaconfig配置Spring
我们现在完全不需要使用Spring的xml配置了，全权交给java来做
JavaConfig是Spring的一个子项目，在Spring4之外，它成为了一个核心功能。
//这里这个注解的意思，就是说这个类被Spring接管了，注册到了容器中
@Component
public class User {
private String name;
public String getName() {
return name;
}
@Value("fan")
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return new StringJoiner(", ", User.class.getSimpleName() + "[", "]")
.add("name='" + name + "'")
.toString();
}
}
//这个也会被Spring容器托管，注册到容器中，因为它本来就是一个component
//@Configuration代表这是一个配置类，就和我们之前看的beans.xml
@Configuration
@ComponentScan("com.fan.pojo")
@Import(Config2.class)
public class Config {
//注册一个Bean 就相当于我们之前写的一个Bean标签
//这个方法的名字 就相当于bean标签中的id属性
//这个方法的返回值 就相当于bean标签中的class属性
@Bean
public User getUser(){
return new User();
}
}
public class Mytest {
@Test
public void test(){
//若果完全使用了配置类的方式去做，我们就只能通过AnnotationConfig上下文来获取容器，通过配置类的class对象加载
ApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
User user = (User) context.getBean("getUser");
System.out.println(user.getName());
}
}
这种纯java配置的方式，在springboot中随处可见！
10.代理模式
为什么要学习代理模式？因为这就是SpringAOP的底层！【SpringAOP和SpringMVC】
代理模式的分类：
- 静态代理
- 动态代理
10.1静态代理
角色分析：
- 抽象角色：一般会使用接口或者抽象类来解决
- 真实角色：被代理的角色
- 代理角色：代理真实角色，代理后一般会做一些附属操作
- 客户：访问代理对象的人
public interface UserService {
public void add();
public void delete();
public void update();
public void query();
}
public class UserServiceImpl implements UserService{
public void add() {
System.out.println("增加了一个用户");
}
public void delete() {
System.out.println("删除了一个用户");
}
public void update() {
System.out.println("修改了一个用户");
}
public void query() {
System.out.println("查询了一个用户");
}
}
public class UserServiceProxy implements UserService{
private UserServiceImpl userService;
public UserServiceProxy(UserServiceImpl userService) {
this.userService = userService;
}
public void add() {
log("add");
userService.add();
}
public void delete() {
log("delete");
userService.delete();
}
public void update() {
log("update");
userService.update();
}
public void query() {
log("query");
userService.query();
}
public void log(String msg){
System.out.println("使用了" + msg + "方法");
}
}
public class Client {
public static void main(String[] args) {
UserServiceImpl userService = new UserServiceImpl();
UserServiceProxy proxy = new UserServiceProxy(userService);
proxy.add();
}
}
代理模式的好处：
- 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
- 公共也就交给代理角色，实现了业务的分工
- 公共业务发生拓展的时候，方便集中管理
缺点：
- 一个真实角色就会产生一个代理角色；代码量会翻倍，卡法效率降低
10.2 动态代理
- 动态代理和静态代理角色一样
- 动态代理的代理类是动态生成的，不是我们直接写好的
- 动态代理分为两大类：基于接口的动态代理，基于类的动态代理
- 基于接口：JDK动态代理
- 基于类：cglib
- java字节码实现：javaassist
需要了解两个类：Proxy：代理， InvocationHandler：调用处理程序
public class Host implements Rent {
public void rent(){
System.out.println("房东要出租房子！");
}
}
//租房
public interface Rent {
public void rent();
}
public class ProxyInvocationHandler implements InvocationHandler {
private Object target;
public void setTarget(Object target) {
this.target = target;
}
//生成得到代理类
public Object getProxy(){
return Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(),this);
}
//处理代理实例 并返回结果
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
log(method.getName());
//动态代理的本质 就是使用反射机制实现
Object result = method.invoke(target, args);
return null;
}
public void log(String msg){
System.out.println("执行了" + msg + "方法");
}
}
public class Client {
public static void main(String[] args) {
//真实角色
UserServiceImpl userService = new UserServiceImpl();
//代理角色 不存在
ProxyInvocationHandler pih = new ProxyInvocationHandler();
//设置要代理的对象
pih.setTarget(userService);
//动态生成代理类
UserService proxy = (UserService) pih.getProxy();
proxy.query();
}
}
动态代理的好处：
- 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
- 公共也就交给代理角色，实现了业务的分工
- 公共业务发生拓展的时候，方便集中管理
- 一个动态代理类代理的是一个接口，一般就是对应的一类业务
- 一个动态代理类可以代理多个类，只要是实现了同一个接口即可
11.AOP
11.1什么是AOP
AOP（Aspect oriented programing）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术，AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
11.2 AOP在Spring中的作用
提供声明式事务；允许用户自定义切面
- 横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志，安全，缓存，事务等等…
- 切面（ASPECT)：横切关注点被模块化的特殊对象。即，它是一个类
- 通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法
- 目标（target）：被通知对象
- 代理（proxy）：向目标对象应用通知之后创建的对象
- 切入点（pointcut）：切面通知 执行的地点的定义
- 连接点（joinpoint）：与切入点匹配的执行点
11.3 使用Spring实现AOP
<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.6</version>
</dependency>
方式一：使用Spring的API接口
<?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 https://www.springframework.org/schema/aop/spring-aop.xsd">
<!--注册bean-->
<bean id="userService" class="com.fan.service.UserServiceimpl"/>
<bean id="log" class="com.fan.log.log"/>
<bean id="afterlog" class="com.fan.log.Afterlog"/>
<!-- 方式一：使用spring API接口-->
<!--配置AOP：需要导入AOP的约束-->
<aop:config>
<!--切入点 expression:表达式，execution（需要执行的位置）-->
<aop:pointcut id="pointcut" expression="execution(* com.fan.service.UserServiceimpl.*(..))"/>
<!-- 执行环绕增加-->
<aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
<aop:advisor advice-ref="afterlog" pointcut-ref="pointcut"/>
</aop:config>
</beans>
public class Mytest {
@Test
public void test(){
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
//动态代理代理的是接口：注意点
UserService userService = (UserService) context.getBean("userService");
userService.add();
}
}
方式二：使用自定义类来实现AOP
<bean id="diy" class="com.fan.diy.DiyPointCut"/>
<aop:config>
<!-- 自定义切面 ref要引用的类-->
<aop:aspect ref="diy">
<!-- 切入点 -->
<aop:pointcut id="pointcut" expression="execution(* com.fan.service.UserServiceimpl.*(..))"/>
<!-- 通知 -->
<aop:before method="before" pointcut-ref="pointcut"></aop:before>
<aop:after method="after" pointcut-ref="pointcut"></aop:after>
</aop:aspect>
</aop:config>
方式三：使用注解
<aop:aspectj-autoproxy/>
<context:component-scan base-package="com.fan"/>
<context:annotation-config/>
@Component
@Aspect
public class AnnotationPointCut {
@Before("execution(* com.fan.service.UserServiceimpl.*(..))")
public void before(){
System.out.println("-------方法执行前------");
}
@After("execution(* com.fan.service.UserServiceimpl.*(..))")
public void after(){
System.out.println("-------方法执行后------");
}
//在环绕增强中 我们可以给定一个参数 代表我们要获取处理切入的点
@Around("execution(* com.fan.service.UserServiceimpl.*(..))")
public void aroud(ProceedingJoinPoint jp) throws Throwable {
System.out.println("环绕前");
Signature signature = jp.getSignature();
System.out.println(signature);
Object proceed = jp.proceed();
System.out.println("环绕后");
System.out.println(proceed);
}
}
12. 整合Mybatis
步骤：
-
导入jar包
- junit
- mybatis
- mysql
- spring
- aop
- mybatis-spring
<dependencies> <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>5.3.6</version> </dependency> <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>5.3.6</version> </dependency> <!-- https://mvnrepository.com/artifact/junit/junit --> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.13.2</version> </dependency> <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver --> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.9.6</version> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.21</version> </dependency> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.7</version> </dependency> <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>5.3.6</version> </dependency> <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring --> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis-spring</artifactId> <version>2.0.6</version> </dependency> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <version>1.18.20</version> </dependency> </dependencies> -
编写配置文件
-
测试
mybatis-spring
- 编写数据源配置
- sqlSessionFactory
- sqlSessionTemplate
- 需要给接口加实现类
- 测试
<?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>
<typeAliases>
<package name="com.fan.pojo"/>
</typeAliases>
</configuration>
<?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 https://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- DataSource:使用spring的数据源替换Mybatis的配置-->
<bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC"/>
<property name="username" value="root"/>
<property name="password" value="123"/>
</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/fan/mapper/*.xml"/>
</bean>
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
<constructor-arg index="0" ref="sqlSessionFactory"/>
</bean>
</beans>
<?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 https://www.springframework.org/schema/aop/spring-aop.xsd">
<import resource="spring-dao.xml"/>
<bean id="userMapper" class="com.fan.mapper.UserMapperImpl">
<property name="sqlSession" ref="sqlSession"/>
</bean>
<bean id="userMapper" class="com.fan.mapper.UserMapperImpl2">
<property name="sqlSessionFactory" ref="sqlSessionFactory"/>
</bean>
</beans>
public class UserMapperImpl implements UserMapper {
private SqlSessionTemplate sqlSession;
public void setSqlSession(SqlSessionTemplate sqlSession) {
this.sqlSession = sqlSession;
}
public List<User> getUser() {
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
return mapper.getUser();
}
}
public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper {
public List<User> getUser() {
return getSqlSession().getMapper(UserMapper.class).getUser();
}
}
public class Mytest {
@Test
public void test(){
ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
UserMapper mapper = context.getBean("userMapper", UserMapper.class);
List<User> users = mapper.getUser();
for (User user : users) {
System.out.println(user);
}
}
}
13.声明式事务
13.1回顾事务
- 要么都成功 要么都失败
- 事务在项目开发中，十分重要，涉及到数据的一致性问题，不能马虎
- 确保完整性和一致性
事务的ACID原则：
- 原子性
- 一致性
- 持久性
- 事务一旦提交，无论系统发生什么问题，结果都不会再被改变，被持久化写到存储器中
- 隔离性
- 多个业务可能操作同一个资源，防止数据损坏
13.2 spring中的事务管理
- 声明式事务：AOP
- 编程式事务：需要在代码中进行事务的管理
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<constructor-arg ref="datasource"/>
</bean>
<!--结合AOP实现事务的织入-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<!-- 给那些方法配置事务-->
<!-- 配置事务的传播特性-->
<tx:attributes>
<tx:method name="add" propagation="REQUIRED"/>
<tx:method name="*"/>
</tx:attributes>
</tx:advice>
<!-- 配置事务切入-->
<aop:config>
<aop:pointcut id="txPointCut" expression="execution(* com.fan.mapper.*.*(..))"/>
<aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
</aop:config>
111
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
