javascript
狂神说Spring学习笔记————（一发入魂）
文章目錄
- 1、Spring
- 1.1、簡介
- 1.2、優(yōu)點
- 1.3、組成
- 2、IOC理論推導
- 2.1、IOC本質(zhì)
- 3 Hello Spring
- 4、IOC創(chuàng)建對象的方式
- 使用無參構(gòu)造創(chuàng)建對象，默認！
- 假設我們要使用有參構(gòu)造創(chuàng)建對象。
- 5、Spring配置
- 5.1、 別名
- 5.2 、Bean的配置
- 5.3 、import
- 6、DI依賴注入
- 6.1、構(gòu)造器注入
- 6.2 、set方式注入【重點】
- 6.3、 擴展方式注入
- P命令
- C命令
- 6.4 、bean的作用域
- 7、bean的自動裝配
- 7.1 、測試
- 7.2、ByName自動裝配
- 7.3、ByTyte自動裝配
- 7.4 、使用注解實現(xiàn)自動裝配
- 7.4.1、 @Autowired與@Resource
- 8、使用注解開發(fā)
- 9、使用Java的方式配置Spring
- 10、代理模式
- 10.1、靜態(tài)代理
- 10.2 、加深理解
- 10.3、動態(tài)代理
- 11、AOP
- 11.1 什么是AOP
- 11.2 AOP在Spring中的作用
- 11.3 使用Spring實現(xiàn)Aop
- 12、整合Mybatis
- 12.1、回憶mybatis
- 12.2、Mybatis-Spring
- 13、聲明式事物
- 13.1、回顧事務
- 13.2、Spring中的事物管理
1、Spring
1.1、簡介
-
Spring：春天----->給軟件行業(yè)帶來春天
-
2002，首次推出Spring框架的出行：interface21的框架！
-
Spring框架級以interface21為基礎，經(jīng)過重新設計，并不斷豐富其內(nèi)涵，于2004年3月24日，發(fā)布了1.0正式版
-
Rod Johnson
Spring Framework創(chuàng)始人，著名作者。 Rod在悉尼大學不僅獲得了計算機學位，同時還獲得了音樂學位。更令人吃驚的是在回到軟件開發(fā)領域之前，他還獲得了音樂學的博士學位。
-
Spring理念：使現(xiàn)有的技術(shù)更加容易使用，本身是一個大雜燴，整合了現(xiàn)有的技術(shù)框架！
-
SSH：Struct2+Spring+hibernate
-
SSM：SpringMVC + Spring + Mybatis!
官網(wǎng)：https://spring.io/projects/spring-framework#overview
官方下載地址：https://repo.spring.io/release/org/springframework/spring/
GitHub：https://github.com/spring-projects/spring-framework
1.2、優(yōu)點
- Spring是一個開源的免費框架（容器）！
- Spring是一個輕量級的，非入侵式的框架！
- 控制反轉(zhuǎn)（IOC），面向切面編程（AOP）！
- 支持事務的處理，對框架整合的支持！
總結(jié)一句話：Spring就是一個輕量級的控制反轉(zhuǎn)（IOC）和面向切面編程（AOP）的框架！
1.3、組成
現(xiàn)代化的Java開發(fā)！說白就是基于Spring的開發(fā)！
- Spring Boot
- 一個快速開發(fā)的腳手架。
- 基于SpringBoot可以快速的開發(fā)單個微服務。
- 約定大于配置。
- Spring Cloud
- SpringCloud是基于SpringBoot實現(xiàn)的。
因為現(xiàn)在大多數(shù)公司都在使用SpringBoot進行快速開發(fā)，學習SpringBoot的前提，需要完全掌握Spring及SpringMVC！承上啟下的作用！
弊端：發(fā)展了太久之后，違背了原來的理念！配置十分繁瑣，人稱“配置地獄”！
2、IOC理論推導
UserDao 接口
UserDaoImpl 實現(xiàn)類
UserService 業(yè)務接口
UserServiceImpl 業(yè)務實現(xiàn)類
在我們之前的業(yè)務中，用戶的需求可能會影響我們原來的代碼，我們需要根據(jù)用戶的需求去修改原代碼！如果程序代碼量十分大，修改一次的成本代價十分昂貴！
private UserDao userDao;//利用set進行動態(tài)實現(xiàn)值的注入！public void setUserDao(UserDao userDao) {this.userDao = userDao;}- 之前，程序是主動創(chuàng)建對象！控制權(quán)在程序猿手上！
- 使用了set注入后，程序不再具有主動性，而是變成了被動的接收對象！
這種思想，從本質(zhì)上解決了問題，我們程序猿不用再去管理對象的創(chuàng)建了。系統(tǒng)的耦合性大大降低~，可以更加專注的在業(yè)務的實現(xiàn)上！這是IOC的原型！
2.1、IOC本質(zhì)
控制反轉(zhuǎn)IoC（Inversion of Control），是一種設計思想，DI（依賴注入）是實現(xiàn)IoC的一種方法，也有人認為DI只是IoC的另一種說法。沒有IoC的程序中，我們使用面向?qū)ο缶幊?#xff0c;對象的創(chuàng)建與對象間的依賴關(guān)系完全硬編碼在程序中，對象的創(chuàng)建由程序自己控制，控制反轉(zhuǎn)后將對象的創(chuàng)建轉(zhuǎn)移給第三方，個人認為所謂控制反轉(zhuǎn)就是：獲得依賴對象的方式反轉(zhuǎn)了。
采用XML方式配置Bean的時候，Bean的定義信息是和實現(xiàn)分離的，而采用注解的方式可以把兩者合為一體，Bean的定義信息直接以注解的形式定義在實現(xiàn)類中，從而達到了零配置的目的。
控制反轉(zhuǎn)是一種通過描述（XML或注解）并通過第三方去生產(chǎn)或獲取特定對象的方式。在Spring中實現(xiàn)控制反轉(zhuǎn)的是IoC容器，其實現(xiàn)方法是依賴注入（Dependency Injection，DI）。
3 Hello Spring
思考問題？
- Hello對象是誰創(chuàng)建的？
Hello對象是由Spring創(chuàng)建的。 - Hello對象的屬性是怎么設置的？
Hello對象的屬性是由Spring容器設置的。
這個過程就叫做控制反轉(zhuǎn)：
控制：誰來控制對象的創(chuàng)建，傳統(tǒng)應用程序的對象是由程序本身控制創(chuàng)建的，使用Spring后，對象是由Spring來創(chuàng)建的。
反轉(zhuǎn)：程序本身不創(chuàng)建對象，而變成被動的接收對象。
依賴注入：就是利用set方法來進行注入的。
IOC是一種編程思想，由主動的編程變成被動的接收。
可以通過new ClassPathXmlApplicationContext去瀏覽一下底層源碼。
針對之前的文檔進行的Spring配置文件的練習
4、IOC創(chuàng)建對象的方式
-
使用無參構(gòu)造創(chuàng)建對象，默認！
2.創(chuàng)建beans.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"><bean id="user" class="com.kuang.pojo2.User"><property name="name" value="秦將"/></bean> </beans>3.創(chuàng)建測試類
public class MyTest {public static void main(String[] args) {ApplicationContext Context= new ClassPathXmlApplicationContext("beans.xml");User user=(User) Context.getBean("user");user.show();} }-
假設我們要使用有參構(gòu)造創(chuàng)建對象。
總結(jié)：在配置文件加載的時候，容器中管理的對象就已經(jīng)初始化了！
5、Spring配置
5.1、 別名
<!--別名，如果添加了別名，我們也可以使用別名獲取到這個對象--> <alias name="user" alias="userNew"/>5.2 、Bean的配置
<!-- id：bean的唯一標識符，也就是相當于我們學的對象名 class：bean對象所對應的全限定名：包名+類名 name：也是別名，而且name可以同時取多個別名--> <bean id="userT" class="com.kuang.pojo.UserT" name="user2 u2,u3;u4"><property name="name" value="黑心白蓮"/> </bean>5.3 、import
這個import。一般用于團隊開發(fā)使用，它可以將多個配置文件，導入合并為一個。
假設，現(xiàn)在項目中有多個人開發(fā)，這三個人負責不同的類開發(fā)，不同的類需要注冊在不同的bean中，我們可以利用import將所有人的beans.xml合并為一個總的！
- 張三
- 李四
- 王五
- applicationContext.xml
使用的時候，直接使用總的applicationContext.xml就可以了。
6、DI依賴注入
6.1、構(gòu)造器注入
（有參，無參構(gòu)造器注入，詳細見4、IOC創(chuàng)建對象的方式）
6.2 、set方式注入【重點】
- 依賴注入：本質(zhì)是set注入
- 依賴：bean對象的創(chuàng)建依賴與容器！
- 注入：bean對象中的所有屬性，有容器注入！
【環(huán)境搭建】
復雜類型
- 搭建其中類Address和Student，并且設置get和setter
- 配置beans.xml
- 測試類
- 完善注入信息
6.3、 擴展方式注入
我們可以使用p命名空間和c命名空間進行注入
官方解釋：
P命令相當于是set注入，C命令相當于構(gòu)造器注入(constructor)
P命令
使用步驟：
1.配置userbeans.xml
xmlns:p="http://www.springframework.org/schema/p" <!--p命令空間注入,可以直接注入屬性的值:property--> <bean id="user" class="com.kuang.pojo.User" p:name="秦將" p:age="18"/>2.修改測試類
@Test public void test2(){ ApplicationContext context= new ClassPathXmlApplicationContext("userbeans.xml"); User user =context.getBean("user", User.class); System.out.println(user);注意：需要導入junit的包
<dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.7</version> </dependency>C命令
1.修改userbears.xml
注意不可以直接注入：需要添加有參和無參構(gòu)造器
xmlns:c="http://www.springframework.org/schema/c" <!--p命令空間注入,不可以直接注入屬性的值:constructor--> <bean id="user2" class="com.kuang.pojo.User" c:name="狂神" c:age="17"/>2.修改測試類
@Test public void test2(){ ApplicationContext context= new ClassPathXmlApplicationContext("userbeans.xml"); User user =context.getBean("user2", User.class); System.out.println(user);注意點：p命名和c命名空間不能直接使用，需要導入xml約束！
xmlns:p="http://www.springframework.org/schema/p" xmlns:c="http://www.springframework.org/schema/c"6.4 、bean的作用域
scope為作用域
注意：singleton表示單例，全局唯一，而prototype表示原型模式，每次從容器中g(shù)et的時候，都會產(chǎn)生一個新對象！
而request.session等是webmvc中使用
1.單例模式（Spring模式模式）
<bean id="user2" class="com.kuang.pojo.User" c:name="狂神" c:age="17" scope="singleton"/>注意：singleton模式下的是一樣的，單線程一般使用單例模式，多線程使用原型模式
測試：
ApplicationContext context= new ClassPathXmlApplicationContext("userbeans.xml"); User user =context.getBean("user2", User.class); User user2 =context.getBean("user2", User.class); System.out.println(user.hashCode()); System.out.println(user2.hashCode()); System.out.println(user==user2);輸出結(jié)果：
[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-JKJanU9J-1638191586706)(C:\Users\jameslzhang\AppData\Roaming\Typora\typora-user-images\image-20211009091310180.png)]
2.原型模式：每次從容器中g(shù)et的時候，都會產(chǎn)生一個新對象
<bean id="user2" class="com.kuang.pojo.User" c:name="狂神" c:age="22" scope="prototype"/>測試：（可以按照單例模式進行測試）
輸出結(jié)果：
[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-34qipxJI-1638191586715)(C:\Users\jameslzhang\AppData\Roaming\Typora\typora-user-images\image-20211010113127074.png)]
7、bean的自動裝配
- 自動裝配是Spring滿足bean依賴一種方式
- Spring會在上下文中自動尋找，并自動給bean裝配屬性
在Spring中有三種裝配方式：
7.1 、測試
環(huán)境搭建：創(chuàng)建項目，一個人有兩個寵物
<?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.kuang.pojo.Cat"/> <bean id="dog" class="com.kuang.pojo.Dog"/> <bean id="people" class="com.kuang.pojo.People"> <property name="name" value="小章"/> <property name="cat" ref="cat"/> <property name="dog" ref="dog"/> </bean></beans>7.2、ByName自動裝配
<bean id="cat" class="com.yang.entity.Cat"/> <bean id="dog" class="com.yang.entity.Dog"/><!-- byName:會在容器上下文中查找，和自己對象set方法后面的值相對應的beanid！ --> <bean id="people" class="com.kuang.pojo.People" autowire="byName"> <property name="name" value="小章"/> </bean>7.3、ByTyte自動裝配
<!--byType：會自動在容器上下文中查找，和自己對象屬性類型相同的bean--> <bean class="com.kuang.pojo.Cat"/> <bean class="com.kuang.pojo.Dog"/> <bean id="people" class="com.kuang.pojo.People" autowire="byType"> <property name="name" value="小章"/> </bean>小結(jié)：
- ByName的時候，需要保證所有bean的id唯一，并且這個bean需要和自動注入的屬性的set方法的值一致！
- ByType的時候，需要保證所有bean的class唯一，并且這個bean需要和自動注入的屬性的類型一致！
7.4 、使用注解實現(xiàn)自動裝配
jdk1.5支持的注解，Spring2.5就支持注解了！
The introduction of annotation-based configuration raised the question of whether this approach is “better” than XML
要使用注解須知：
1.導入約束。context約束
2.配置注解【注意：context:annotation-config 開啟注解的支持】
<?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 https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd"> <!--開啟注解的支持 --> <context:annotation-config/></beans> <bean id="cat" class="com.kuang.pojo.Cat"/> <bean id="dog" class="com.kuang.pojo.Dog"/> <bean id="people" class="com.kuang.pojo.People" />@Autowired
直接在屬性上使用即可！也可以在set方法上使用！
[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-DEK8SBTn-1638191586720)(C:\Users\jameslzhang\AppData\Roaming\Typora\typora-user-images\image-20211010094952302.png)]
使用Autowired我們就可以不用編寫set方法了，前提是你這個自動配置的屬性在IOC（Spring）容器中存在，且符合名字ByName！
7.4.1、 @Autowired與@Resource
@Autowired
直接在屬性上使用即可！也可以在set方式上使用
使用Autowired我們可以不用編寫set方法了，前提是你這個自動裝配的屬性在IOC（Spring）容器中存在，且符合名字byName
科普:
@Nullable 字段標記了這個注解，說明這個字段可以為null； public @interface Autowired { boolean required() default true;}測試代碼：
public class People { //如果顯式定義了Autowired的required屬性為false，說明這個對象可以為null，否則不允許為空 @Autowired(required = false) private Cat cat; @Autowired private Dog dog; private String name;}如果@Autowired自動裝配的環(huán)境比較復雜，自動裝配無法通過一個注解【@Autowired】完成的時候，我們可以使用@Qualifier(value = “xxx”)去配置@Autowired的使用，指定一個唯一的bean對象注入！
public class People { @Autowired @Qualifier(value = "cat111") private Cat cat; @Autowired @Qualifier(value = "dog222") private Dog dog; private String name;}@Resource注解，不指定name值，先去判斷byName和byType，有一個能注入即成功
public class People { @Resource(name = "xxxx") private Cat cat;小結(jié)：@Resource和@Autowired的區(qū)別
- 都是用來自動裝配的，都可以放在屬性字段上
- @Autowired通過Bytype的方式實現(xiàn)，而且必須要求這個對象存在！【常用】
- @Resource默認通過ByName的方式實現(xiàn)，如果找不到名字，則可以通過Bytype實現(xiàn)，功能較為強大，如果兩個都找不到的情況下，就會報錯！【常用】
- 執(zhí)行順序的不同：@Autowired通過ByType的方式實現(xiàn)。@Resource默認通過byName的方式實現(xiàn)。
8、使用注解開發(fā)
在Spring4之后，要使用注解開發(fā)，必須要保證aop的包導入了
使用注解需要導入約束，配置注解的支持！
<?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/beanshttps://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttps://www.springframework.org/schema/context/spring-context.xsd"><!--開啟注解的支持 --><context:annotation-config/></beans>1. bean注入使用@Componet注解
//@Component 等價于<bean id="user" class="com.kuang.pojo"/> @Component public class User {public String name="qian"; }- 或者使用value注入
- 或者使用set方法進行注入
2.測試類
public class Mytest { public static void main(String[] args) { ApplicationContext context= new ClassPathXmlApplicationContext("appicationContext.xml"); User user=(User) context.getBean("user"); System.out.println(user.name); }}3.衍生的注解
@Component有幾個衍生注解，我們在web開發(fā)中，會按照mvc三層架構(gòu)分層！衍生注解都是和Component一樣的
這四個注解功能都是一樣的，都是代表將某個類注冊到Spring中，裝配Bean
4.自動裝配
- @Autowired：自動裝配通過類型，名字。如果Autowired不能唯一自動裝配上屬性，則需要通過@Qualifier(value = "xxx")去配置。- @Nullable 字段標記了了這個注解，說明這個字段可以為null;- @Resource：自動裝配通過名字，類型。5.作用域
@Scope(“singleton”)單例模式
@Scope(“prototype”)原型模式
@Component@Scope("singleton")public class User { public String name="qian"; @Value("qianli2") public void setName(String name) { this.name = name; }}6.小結(jié)
xml與注解：
- xml更加萬能，適用于任何場合！維護簡單房間
- 注解不是自己的類使用不了，維護相對負責
xml與注解最佳實踐：
- xml用來管理bean；
- 注解只負責完成屬性的注入；
- 我們在使用過程中，只需要注意個問題：必須讓注解生效，就需要開啟注解的支持
9、使用Java的方式配置Spring
我們現(xiàn)在要完全不使用Spring的xml配置了，全權(quán)交給Java來做！
JavaConfig是Spring的一個子項目，在Spring4之后，它成為了一個核心功能！[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-4VKZXOKt-1638191586727)(C:\Users\jameslzhang\AppData\Roaming\Typora\typora-user-images\image-20211010140328630.png)]
-
實體類
- //這里這個是注解的意思，就是說明這個類被Spring接管了，注冊到了容器中@Componentpublic class User { private String name; public String getName() { return name; } @Value("qinjiang")//屬性注入值 public void setName(String name) { this.name = name; } @Override public String toString() { return "User{" + "name='" + name + '\'' + '}'; }}
-
配置文件
測試類
public class Mytest { public static void main(String[] args) { //如果完全使用了配置類方式去做，我們就只能通過AnnotationConfig上下文來獲取容器，通過配置類的class對象加載！ ApplicationContext context= new AnnotationConfigApplicationContext(KuangConfig.class); User getuser=(User) context.getBean("getUser"); System.out.println(getuser.getName()); }}這種純Java的配置方式，在SpringBoot中隨處可見！
10、代理模式
為什么要學習代理模式？因為這就是SpringAOP的底層！【SpringAOP和SpringMVC】
代理模式的分類：
- 靜態(tài)代理
- 動態(tài)代理
[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-aWEdHVRl-1638191586735)(C:\Users\jameslzhang\AppData\Roaming\Typora\typora-user-images\image-20211010222814373.png)]
10.1、靜態(tài)代理
角色分析：
- 抽象角色：一般會使用接口或者抽象類來解決
- 真實角色：被代理的角色
- 代理角色：代理真實角色，代理真實角色后，我們一般會做一些附屬操作
- 客戶：訪問代理對象的人
代碼步驟：
代理模式的好處：
- 可以使真實角色的操作更加純粹！不用去關(guān)注一些公共的業(yè)務
- 公共的業(yè)務也就交給代理角色！實現(xiàn)了業(yè)務的分工
- 公共業(yè)務發(fā)生擴展的時候，方便集中管理！
缺點：
- 一個真實角色就會產(chǎn)生一個代理角色：代碼量會翻倍，開發(fā)效率較低
10.2 、加深理解
代碼步驟：
問題：
-
為什么使用代理模式？
符合面向?qū)ο蟮钠叽笤瓌t，因為在公司中修改他人書寫的源代碼可以直接導致代碼崩盤！
[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-h8mPuCQF-1638191586739)(C:\Users\jameslzhang\AppData\Roaming\Typora\typora-user-images\image-20211011000528194.png)]
10.3、動態(tài)代理
- 動態(tài)代理和靜態(tài)代理一樣
- 動態(tài)代理的代理類是動態(tài)生成的，不是我們直接寫好的！
- 動態(tài)代理分為兩大類：基于接口的動態(tài)dialing，基于類的動態(tài)代理
- 基于接口——JDK動態(tài)代理【我們在這里使用】
- 基于類：cglib
- Java字節(jié)碼實現(xiàn)：javasist
需要了解兩個類：Proxy（代理）.InvocationHandler（調(diào)用處理程序）
代碼實現(xiàn)步驟：
-
注意：上述方法比較麻煩，我們可以采用較為簡單的方法，進行自動生成代理類
//等我們會用這個類，自動生成代理類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); } //處理代理實例，并返回結(jié)果 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { log(method.getName()); Object result=method.invoke(target,args); return result; } public void log(String msg){ System.out.println("[Debug] 使用了一個"+msg+"方法"); }}- 測試
動態(tài)代理的好處：
- 可以是真實角色操作更加純粹！不用去關(guān)注一些公共的業(yè)務
- 公共角色就交給代理角色！實現(xiàn)了業(yè)務的分工
- 公共業(yè)務發(fā)生擴展的時候，方便集中管理
- 一個動態(tài)代理類代理的是一個接口，一般對應的一類業(yè)務
- 一個動態(tài)代理類可以代理多個類，只要是實現(xiàn)了同一個接口！
11、AOP
11.1 什么是AOP
AOP（Aspect Oriented Programming）意為：面向切面編程，通過預編譯方式和運行期動態(tài)代理實現(xiàn)程序功能的統(tǒng)一維護的一種技術(shù)。AOP是OOP的延續(xù)，是軟件開發(fā)中的一個熱點，也是Spring框架中的一個重要內(nèi)容，是函數(shù)式編程的一種衍生范型。利用AOP可以對業(yè)務邏輯的各個部分進行隔離，從而使得業(yè)務邏輯各部分之間的耦合度降低，提高程序的可重用性，同時提高了開發(fā)的效率。
[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-EZlwg5bF-1638191586741)(C:\Users\jameslzhang\AppData\Roaming\Typora\typora-user-images\image-20211012231104045.png)]
11.2 AOP在Spring中的作用
提供聲明式事務；允許用戶自定義切面
- 橫切關(guān)注點：跨越應用程序多個模塊的方法或功能。即是，與我們業(yè)務邏輯無關(guān)的，但是我們需要關(guān)注的部分，就是橫切關(guān)注點。如日志，安全，緩存，事務等等…
- 切面（ASPECT）：橫切關(guān)注點被模塊化的特殊對象。即，它是一個類。
- 通知（Advice）：切面必須要完成的工作。即，它是類中的一個方法。
- 目標（Target）：被通知對象。
- 代理（Proxy）：向目標對象應用通知之后創(chuàng)建的對象。
- 切入點（PointCut）：切面通知執(zhí)行的“地點”的定義。
- 連接點（JointPoint）：與切入點匹配的執(zhí)行點
[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-VIbNrIHL-1638191586745)(C:\Users\jameslzhang\AppData\Roaming\Typora\typora-user-images\image-20211012231307452.png)]
SpringAOP中，通過Advice定義橫切邏輯，Spring中支持5種類型的Advice：
[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-XolcMDHW-1638191586748)(C:\Users\jameslzhang\AppData\Roaming\Typora\typora-user-images\image-20211012231359232.png)]
即AOP在不改變原有代碼的情況下，去增加新的功能。
11.3 使用Spring實現(xiàn)Aop
【重點】使用AOP織入，需要依賴包
<dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.9.4</version></dependency>方式一： 使用Spring的API接口【主要是SpringAPI接口實現(xiàn)】
方式二： 自定義類來實現(xiàn)AOP【主要是切面定義】
- 與方式一測試一樣
方式三： 使用注解實現(xiàn)！
在diy包下定義注解實現(xiàn)的AnnotationPointCut增強類
//聲明式事務！ @Aspect //標注這個類是一個切面 public class AnnotationPointCut {@Before("execution(* com.kuang.service.UserServiceImpl.*(..))")public void before(){System.out.println("====方法執(zhí)行前====");}@After("execution(* com.kuang.service.UserServiceImpl.*(..))")public void after(){System.out.println("====方法執(zhí)行后====");}//在環(huán)繞增強中，我們可以給定一個參數(shù)，代表我們要獲取處理切入的點；@Around("execution(* com.kuang.service.UserServiceImpl.*(..))")public void around(ProceedingJoinPoint jp) throws Throwable{System.out.println("環(huán)繞前");Signature signature = jp.getSignature();// 獲得簽名System.out.println("signature:"+signature);Object proceed = jp.proceed(); //執(zhí)行方法System.out.println("環(huán)繞后");System.out.println(proceed);}}[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-AgiwYUsA-1638191586753)(C:\Users\jameslzhang\AppData\Roaming\Typora\typora-user-images\image-20211013114836793.png)]
注意執(zhí)行順序：環(huán)繞前→方法執(zhí)行前→環(huán)繞后→方法執(zhí)行后
12、整合Mybatis
步驟：
- junit
- mybatis
- mysql數(shù)據(jù)庫
- spring相關(guān)的
- aop織入器
- mybatis-spring【new】
- 配置Maven靜態(tài)資源過濾問題！
12.1、回憶mybatis
1.編寫pojo實體類
package com.kuang.pojo; public class User { private int id; //id private String name; //姓名 private String pwd; //密碼}2.編寫mybatis核心配置文件
<?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.kuang.pojo"/> </typeAliases> <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/mybatis?useSSL=true&useUnicode=true&characterEncoding=utf8"/> <property name="username" value="root"/> <property name="password" value="123456"/> </dataSource> </environment> </environments> <mappers> <package name="com.kuang.mapper.UserMapper"/> </mappers></configuration>3.UserDao編寫接口
public interface UserMapper { public List<User> selectUser();}4.編寫接口對應的Mapper.xml映射文件
<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"><mapper namespace="com.kuang.dao.UserMapper"> <select id="selectUser" resultType="User"> select * from user </select> </mapper>5.測試類
@Test public void test() throws IOException { String resource="mybatis-config.xml"; InputStream inputStream= Resources.getResourceAsStream(resource); SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(inputStream); SqlSession sqlSession=sqlSessionFactory.openSession(); UserMapper mapper=sqlSession.getMapper(UserMapper.class); List<User> userList=mapper.selectUser(); for(User user:userList){ System.out.println(user); } sqlSession.close(); }12.2、Mybatis-Spring
引入Spring之前需要了解mybatis-spring包中的一些重要類；
http://www.mybatis.org/spring/zh/index.html
[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-73Rte2bm-1638191586755)(C:\Users\jameslzhang\AppData\Roaming\Typora\typora-user-images\image-20211128195703834.png)]
什么是 MyBatis-Spring？
MyBatis-Spring 會幫助你將 MyBatis 代碼無縫地整合到 Spring 中。
知識基礎
在開始使用 MyBatis-Spring 之前，你需要先熟悉 Spring 和 MyBatis 這兩個框架和有關(guān)它們的術(shù)語。這很重要
MyBatis-Spring 需要以下版本：
| 2.0 | 3.5+ | 5.0+ | 4.0+ | Java 8+ |
| 1.3 | 3.4+ | 3.2.2+ | 2.1+ | Java 6+ |
如果使用 Maven 作為構(gòu)建工具，僅需要在 pom.xml 中加入以下代碼即可：
<dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis-spring</artifactId> <version>2.0.2</version></dependency>要和 Spring 一起使用 MyBatis，需要在 Spring 應用上下文中定義至少兩樣東西：一個 SqlSessionFactory 和至少一個數(shù)據(jù)映射器類。
在 MyBatis-Spring 中，可使用SqlSessionFactoryBean來創(chuàng)建 SqlSessionFactory。要配置這個工廠 bean，只需要把下面代碼放在 Spring 的 XML 配置文件中：
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> <property name="dataSource" ref="dataSource" /></bean>注意：SqlSessionFactory需要一個 DataSource（數(shù)據(jù)源）。這可以是任意的 DataSource，只需要和配置其它 Spring 數(shù)據(jù)庫連接一樣配置它就可以了。
在基礎的 MyBatis 用法中，是通過 SqlSessionFactoryBuilder 來創(chuàng)建 SqlSessionFactory 的。而在 MyBatis-Spring 中，則使用 SqlSessionFactoryBean 來創(chuàng)建。
在 MyBatis 中，你可以使用 SqlSessionFactory 來創(chuàng)建 SqlSession。一旦你獲得一個 session 之后，你可以使用它來執(zhí)行映射了的語句，提交或回滾連接，最后，當不再需要它的時候，你可以關(guān)閉 session。
SqlSessionFactory有一個唯一的必要屬性：用于 JDBC 的 DataSource。這可以是任意的 DataSource 對象，它的配置方法和其它 Spring 數(shù)據(jù)庫連接是一樣的。
一個常用的屬性是 configLocation，它用來指定 MyBatis 的 XML 配置文件路徑。它在需要修改 MyBatis 的基礎配置非常有用。通常，基礎配置指的是 < settings> 或 < typeAliases>元素。
需要注意的是，這個配置文件并不需要是一個完整的 MyBatis 配置。確切地說，任何環(huán)境配置（），數(shù)據(jù)源（）和 MyBatis 的事務管理器（）都會被忽略。SqlSessionFactoryBean 會創(chuàng)建它自有的 MyBatis 環(huán)境配置（Environment），并按要求設置自定義環(huán)境的值。
SqlSessionTemplate 是 MyBatis-Spring 的核心。作為 SqlSession 的一個實現(xiàn)，這意味著可以使用它無縫代替你代碼中已經(jīng)在使用的 SqlSession。
模板可以參與到 Spring 的事務管理中，并且由于其是線程安全的，可以供多個映射器類使用，你應該總是用 SqlSessionTemplate 來替換 MyBatis 默認的 DefaultSqlSession 實現(xiàn)。在同一應用程序中的不同類之間混雜使用可能會引起數(shù)據(jù)一致性的問題。
可以使用 SqlSessionFactory 作為構(gòu)造方法的參數(shù)來創(chuàng)建 SqlSessionTemplate 對象。
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate"> <constructor-arg index="0" ref="sqlSessionFactory" /></bean>現(xiàn)在，這個 bean 就可以直接注入到你的 DAO bean 中了。你需要在你的 bean 中添加一個 SqlSession 屬性，就像下面這樣：
public class UserDaoImpl implements UserDao { private SqlSession sqlSession; public void setSqlSession(SqlSession sqlSession) { this.sqlSession = sqlSession; } public User getUser(String userId) { return sqlSession.getMapper...; }}按下面這樣，注入 SqlSessionTemplate：
<bean id="userDao" class="org.mybatis.spring.sample.dao.UserDaoImpl"> <property name="sqlSession" ref="sqlSession" /></bean>整合實現(xiàn)一
1、引入Spring配置文件beans.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 https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd"></beans>2、配置數(shù)據(jù)源替換mybaits的數(shù)據(jù)源
<!--配置數(shù)據(jù)源：數(shù)據(jù)源有非常多，可以使用第三方的，也可使使用Spring的--><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/mybatis?useSSL=true&useUnicode=true&characterEncoding=utf8"/> <property name="username" value="root"/> <property name="password" value="123456"/></bean>3、配置SqlSessionFactory，關(guān)聯(lián)MyBatis
<!--配置SqlSessionFactory--><bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> <property name="dataSource" ref="dataSource"/> <!--關(guān)聯(lián)Mybatis--> <property name="configLocation" value="classpath:mybatis-config.xml"/> <property name="mapperLocations" value="classpath:com/kuang/dao/*.xml"/></bean>4、注冊sqlSessionTemplate，關(guān)聯(lián)sqlSessionFactory；
<!--注冊sqlSessionTemplate , 關(guān)聯(lián)sqlSessionFactory--><bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate"> <!--利用構(gòu)造器注入--> <constructor-arg index="0" ref="sqlSessionFactory"/></bean>5、增加Dao接口的實現(xiàn)類；私有化sqlSessionTemplate
public class UserDaoImpl implements UserMapper { //sqlSession不用我們自己創(chuàng)建了，Spring來管理 private SqlSessionTemplate sqlSession; public void setSqlSession(SqlSessionTemplate sqlSession) { this.sqlSession = sqlSession; } public List<User> selectUser() { UserMapper mapper = sqlSession.getMapper(UserMapper.class); return mapper.selectUser(); } }6、注冊bean實現(xiàn)
<bean id="userDao" class="com.kuang.dao.UserDaoImpl"> <property name="sqlSession" ref="sqlSession"/></bean>7、測試
@Test public void test2(){ ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml"); UserMapper mapper = (UserMapper) context.getBean("userDao"); List<User> user = mapper.selectUser(); System.out.println(user); }結(jié)果成功輸出！現(xiàn)在我們的Mybatis配置文件的狀態(tài)！發(fā)現(xiàn)都可以被Spring整合！
<?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.kuang.pojo"/> </typeAliases></configuration>整合實現(xiàn)二
mybatis-spring1.2.3版以上的才有這個 .
官方文檔截圖 :
dao繼承Support類 , 直接利用 getSqlSession() 獲得 , 然后直接注入SqlSessionFactory . 比起方式1 , 不需要管理SqlSessionTemplate , 而且對事務的支持更加友好 . 可跟蹤源碼查看
[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-m2PTYgZv-1638191586759)(C:\Users\jameslzhang\AppData\Roaming\Typora\typora-user-images\image-20211128200622599.png)]
測試：
1、將我們上面寫的UserDaoImpl修改一下
public class UserDaoImpl extends SqlSessionDaoSupport implements UserMapper { public List<User> selectUser() { UserMapper mapper = getSqlSession().getMapper(UserMapper.class); return mapper.selectUser(); }}2、修改bean的配置
<bean id="userDao" class="com.kuang.dao.UserDaoImpl"> <property name="sqlSessionFactory" ref="sqlSessionFactory" /></bean>3、測試
@Testpublic void test2(){ ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml"); UserMapper mapper = (UserMapper) context.getBean("userDao"); List<User> user = mapper.selectUser(); System.out.println(user);}13、聲明式事物
13.1、回顧事務
-
把一組業(yè)務當成一個業(yè)務來做；要么都成功，要么都失敗！
-
事務在項目開發(fā)中，十分的重要，涉及到數(shù)據(jù)的一致性問題，不能馬虎！
-
確保完整性和一致性。
事務ACID原則：
- 原子性（atomicity）
- 事務是原子性操作，由一系列動作組成，事務的原子性確保動作要么全部完成，要么完全不起作用。
- 一致性（consistency）
- 一旦所有事務動作完成，事務就要被提交。數(shù)據(jù)和資源處于一種滿足業(yè)務規(guī)則的一致性狀態(tài)中。
- 隔離性（isolation）
- 可能多個事務會同時處理相同的數(shù)據(jù)，因此每個事務都應該與其他事務隔離開來，防止數(shù)據(jù)損壞。
- 持久性（durability）
- 事務一旦完成，無論系統(tǒng)發(fā)生什么錯誤，結(jié)果都不會受到影響。通常情況下，事務的結(jié)果被寫到持久化存儲器中。
測試
將上面的代碼拷貝到一個新項目中
在之前的案例中，我們給userMapper接口新增兩個方法，刪除和增加用戶；
UserMapper文件，我們故意把 deletes 寫錯，測試！
<insert id="addUser" parameterType="com.kuang.pojo.User">insert into user (id,name,pwd) values (#{id},#{name},#{pwd})</insert><delete id="deleteUser" parameterType="int">deletes from user where id = #{id}</delete>編寫接口的UserMapperImpl實現(xiàn)類，在實現(xiàn)類中，我們?nèi)ゲ僮饕徊?/p> public class UserMapperImpl extends SqlSessionDaoSupport implements UserMapper {//增加一些操作public List<User> selectUser() {User user = new User(5, "小王", "185161");UserMapper mapper = getSqlSession().getMapper(UserMapper.class);mapper.addUser(user);mapper.deleteUser(5);return mapper.selectUser();}//新增public int addUser(User user) {return getSqlSession().getMapper(UserMapper.class).addUser(user);}//刪除public int deleteUser(int id) {return getSqlSession().getMapper(UserMapper.class).deleteUser(id);} }
測試
@Test public void test(){ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");UserMapper userMapper = context.getBean("userMapper", UserMapper.class);for (User user : userMapper.selectUser()) {System.out.println(user);} }報錯：sql異常，delete寫錯了
結(jié)果 ：數(shù)據(jù)庫結(jié)果顯示插入成功！
沒有進行事務的管理；我們想讓他們都成功才成功，有一個失敗，就都失敗，我們就應該需要事務！
以前我們都需要自己手動管理事務，十分麻煩！
但是Spring給我們提供了事務管理，我們只需要配置即可；
13.2、Spring中的事物管理
Spring在不同的事務管理API之上定義了一個抽象層，使得開發(fā)人員不必了解底層的事務管理API就可以使用Spring的事務管理機制。Spring支持編程式事務管理和聲明式的事務管理。
編程式事務管理
-
將事務管理代碼嵌到業(yè)務方法中來控制事務的提交和回滾
-
缺點：必須在每個事務操作業(yè)務邏輯中包含額外的事務管理代碼
聲明式事務管理
- 一般情況下比編程式事務好用。
- 將事務管理代碼從業(yè)務方法中分離出來，以聲明的方式來實現(xiàn)事務管理。
- 將事務管理作為橫切關(guān)注點，通過aop方法模塊化。Spring中通過Spring AOP框架支持聲明式事務管理。
1. 使用Spring管理事務，注意頭文件的約束導入 : tx
xmlns:tx="http://www.springframework.org/schema/tx"http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">事務管理器
- 無論使用Spring的哪種事務管理策略（編程式或者聲明式）事務管理器都是必須的。
- 就是 Spring的核心事務管理抽象，管理封裝了一組獨立于技術(shù)的方法。
2. JDBC事務
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"><property name="dataSource" ref="dataSource"/></bean>3. 配置好事務管理器后我們需要去配置事務的通知
<!--配置事務通知--> <tx:advice id="txAdvice" transaction-manager="transactionManager"><tx:attributes><!--配置哪些方法使用什么樣的事務,配置事務的傳播特性--><tx:method name="add" propagation="REQUIRED"/><tx:method name="delete" propagation="REQUIRED"/><tx:method name="update" propagation="REQUIRED"/><tx:method name="search*" propagation="REQUIRED"/><tx:method name="get" read-only="true"/><tx:method name="*" propagation="REQUIRED"/></tx:attributes> </tx:advice>spring事務傳播特性：
事務傳播行為就是多個事務方法相互調(diào)用時，事務如何在這些方法間傳播。spring支持7種事務傳播行為：
- propagation_requierd：如果當前沒有事務，就新建一個事務，如果已存在一個事務中，加入到這個事務中，這是最常見的選擇。
- propagation_supports：支持當前事務，如果沒有當前事務，就以非事務方法執(zhí)行。
- propagation_mandatory：使用當前事務，如果沒有當前事務，就拋出異常。
- propagation_required_new：新建事務，如果當前存在事務，把當前事務掛起。
- propagation_not_supported：以非事務方式執(zhí)行操作，如果當前存在事務，就把當前事務掛起。
- propagation_never：以非事務方式執(zhí)行操作，如果當前事務存在則拋出異常。
- propagation_nested：如果當前存在事務，則在嵌套事務內(nèi)執(zhí)行。如果當前沒有事務，則執(zhí)行與propagation_required類似的操作
- Spring 默認的事務傳播行為是 PROPAGATION_REQUIRED，它適合于絕大多數(shù)的情況。
假設 ServiveX#methodX() 都工作在事務環(huán)境下（即都被 Spring 事務增強了），假設程序中存在如下的調(diào)用鏈：Service1#method1()->Service2#method2()->Service3#method3()，那么這 3 個服務類的 3 個方法通過 Spring 的事務傳播機制都工作在同一個事務中。
就好比，我們剛才的幾個方法存在調(diào)用，所以會被放在一組事務當中！
配置AOP
4. 導入aop的頭文件！
<!--配置aop織入事務--> <aop:config><aop:pointcut id="txPointcut" expression="execution(* com.kuang.dao.*.*(..))"/><aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/> </aop:config>5. 進行測試
刪掉剛才插入的數(shù)據(jù)，再次測試！
@Test public void test2(){ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");UserMapper mapper = (UserMapper) context.getBean("userDao");List<User> user = mapper.selectUser();System.out.println(user); }思考：
為什么需要事務？
- 如果不配置事務，可能存在數(shù)據(jù)提交不一致的情況；
- 如果我們不在Spring中去配置聲明式事務，我們就需要在代碼中手動配置事務！
- 事務在項目的開發(fā)中十分重要，涉及到數(shù)據(jù)的一致性和完整性問題，不容馬虎！
總結(jié)
以上是生活随笔為你收集整理的狂神说Spring学习笔记————（一发入魂）的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： MongoDB的安装与可视化工具Stud
- 下一篇： Mac下将ISO写入U盘镜像