當前位置：首頁 > 前端技术 > javascript >内容正文

javascript

狂神说Spring学习笔记————（一发入魂）

發(fā)布時間：2024/1/8 javascript 33 豆豆

生活随笔收集整理的這篇文章主要介紹了狂神说Spring学习笔记————（一发入魂）小編覺得挺不錯的,現(xiàn)在分享給大家,幫大家做個參考.

文章目錄

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

<dependency><groupId>org.springframework</groupId><artifactId>spring-webmvc</artifactId><version>5.2.0.RELEASE</version> </dependency>  <dependency><groupId>org.springframework</groupId><artifactId>spring-jdbc</artifactId><version>5.2.0.RELEASE</version> </dependency>

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

新建一個maven項目，編寫實體類

public class Hello {private String str;public String getStr() {return str;}public void setStr(String str) {this.str = str;}@Overridepublic String toString() {return "Hello{" +"str='" + str + '\'' +'}';} }

編寫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/beanshttps://www.springframework.org/schema/beans/spring-beans.xsd"><bean id="hello" class="com.kuang.pojo.Hello"><property name="str" value="Spring"/></bean> </beans>

測試

public static void main(String[] args) {//獲取Spring的上下文對象！ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");//我們的對象現(xiàn)在都在Spring中的管理了，我們需要使用，直接去里面取出來就可以！Hello hello = (Hello) context.getBean("hello");System.out.println(hello.toString());}

思考問題？

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配置文件的練習

添加beans.xml文件

修改test文件

//獲取ApplicationContext:拿到Spring的容器ApplicationContext context= new ClassPathXmlApplicationContext("beans.xml");//容器在手，天下我有，需要什么，直接get什么UserServiceImpl userServiceImpl=(UserServiceImpl) context.getBean("UserServiceImpl");userServiceImpl.getUser();

4、IOC創(chuàng)建對象的方式

使用無參構(gòu)造創(chuàng)建對象，默認！

創(chuàng)建user類

package com.kuang.pojo2;public class User {private String name;public User(){System.out.println("User的無參構(gòu)造");}public String getName() {return name;}public void setName(String name) {this.name = name;}public void show(){System.out.println("name"+name);} }

2.創(chuàng)建beans.xml

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)建對象。

下標賦值

<bean id="user" class="com.kuang.pojo2.User"><constructor-arg index="0" value="狂神說Java"/> </bean>

類型,通過類型創(chuàng)建有參構(gòu)造，不建議使用

<bean id="user" class="com.kuang.pojo2.User"><constructor-arg type="java.lang.String" value="秦將"/> </bean>

第三種直接通過參數(shù)名進行設置

<bean id="user" class="com.kuang.pojo2.User"><constructor-arg name="name" value="qinjiang"/> </bean>

總結(jié)：在配置文件加載的時候，容器中管理的對象就已經(jīng)初始化了！

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="黑心白蓮"/> </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

package com.kuang.pojo;public class Address {private String address;public String getAddress() {return address;}public void setAddress(String address) {this.address = address;} } package com.kuang.pojo;import com.sun.xml.internal.ws.wsdl.writer.document.http.Address;import java.lang.ref.SoftReference; import java.util.Arrays; import java.util.List; import java.util.Map; import java.util.Properties;public class Student {private String name;private Address address;private String[] books;private List<String> hobbies;private Map<String,String> card;private String wife;private Properties info;//配置文件所使用的類} }

配置beans.xml

測試類

public class MyTest { public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml"); Student student = (Student) context.getBean("student"); System.out.println(student.getName()); }}

完善注入信息

6.3、擴展方式注入

我們可以使用p命名空間和c命名空間進行注入
官方解釋：

P命令相當于是set注入，C命令相當于構(gòu)造器注入(constructor)

P命令

使用步驟：

1.配置userbeans.xml

xmlns:p="http://www.springframework.org/schema/p"  <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"  <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模式模式）

注意：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)生一個新對象

測試：（可以按照單例模式進行測試）

輸出結(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中有三種裝配方式：

在xml顯示的配置（ID依賴注入）

在java中顯示配置（java config中配置）

隱式的自動裝配bean【重要】

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自動裝配

7.3、ByTyte自動裝配

<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 開啟注解的支持】

@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的包導入了

使用注解需要導入約束，配置注解的支持！

1. bean注入使用@Componet注解

//@Component 等價于<bean id="user" class="com.kuang.pojo"/> @Component public class User {public String name="qian"; }

或者使用value注入

//相當于 <property name="name" value="qianli"/> @Component public class User {@Value("qianli")public String name="qian"; }

或者使用set方法進行注入

@Value("qianli2")public void setName(String name) {this.name = name;}

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一樣的

dao 【@Repository】service 【@Service】controller 【@Controller】

這四個注解功能都是一樣的，都是代表將某個類注冊到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；
注解只負責完成屬性的注入；
我們在使用過程中，只需要注意個問題：必須讓注解生效，就需要開啟注解的支持

<context:annotation-config/>  <context:component-scan base-package="com.kuang"/>

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 + '\'' + '}'; }}
配置文件

//這個也會spring容器托管，因為他本來就是一個@component，@Configuration代表這個是一個配置類，就和我們之前看的beans.xml @Configuration @ComponentScan("com.kuang.java") public class KuangConfig { //注冊已被bean，即相當于我們之前寫的一個bean標簽 //這個方法的名字，就相當于bean標簽中的id屬性 //這個方法的返回值，就相當于bean標簽中的class屬性 @Bean public User getUser(){ return new User();//就是返回要注入到bean的對象！ } }

測試類

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)代理

角色分析：

抽象角色：一般會使用接口或者抽象類來解決
真實角色：被代理的角色
代理角色：代理真實角色，代理真實角色后，我們一般會做一些附屬操作
客戶：訪問代理對象的人

代碼步驟：

接口

//接口 public interface Rent {public void rent(); }

真實角色

//房東 public class Hosts implements Rent {public void rent(){System.out.println("房東要出租房子！");} }

代理角色

public class Porxy implements Rent {private Hosts hosts;public Porxy() {}public Porxy(Hosts hosts) {this.hosts = hosts;}public void rent() {hosts.rent();seehouses();sign();fee();}//看房public void seehouses(){System.out.println("中介帶著我要看房子！");}//簽合同public void sign(){System.out.println("和中介簽署租賃合同！");}//收費用public void fee(){System.out.println("中介收取費用！");} }

客戶端訪問代理角色

public class Client { public static void main(String[] args) { //房東要出租房子 Hosts hosts=new Hosts(); //hosts.rent(); //代理，中介幫房東出租房子，并且代理角色一般會有一些復數(shù)操作！ Porxy porxy=new Porxy(hosts); //不用直接面對房東，直接找中介租房即可 porxy.rent(); }}

代理模式的好處：

可以使真實角色的操作更加純粹！不用去關(guān)注一些公共的業(yè)務
公共的業(yè)務也就交給代理角色！實現(xiàn)了業(yè)務的分工
公共業(yè)務發(fā)生擴展的時候，方便集中管理！

缺點：

一個真實角色就會產(chǎn)生一個代理角色：代碼量會翻倍，開發(fā)效率較低

10.2 、加深理解

代碼步驟：

接口

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("查看了一個用戶");} }

代理角色

ublic class UserServicePorxy implements UserService{private UserServiceImpl userService;public void setUserService(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("[debug]使用了"+msg+"方法");} }

客戶端訪問代理角色

public class Client { public static void main(String[] args) { UserServiceImpl userService=new UserServiceImpl(); UserServicePorxy proxy=new UserServicePorxy(); proxy.setUserService(userService); proxy.add(); }}

問題：

為什么使用代理模式？

符合面向?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 interface Rent { public void rent();}

真實角色

public class Host implements Rent{ public void rent() { System.out.println("房東要出租房子！"); }}

ProxyInvocationHandler類

//我們會用這個類，自動生成代理類！public class ProxyInvocationHandler implements InvocationHandler { //被代理的接口 private Rent rent; public void setRent(Rent rent) { this.rent = rent; } //生成得到代理類 public Object getProxy(){ return Proxy.newProxyInstance(this.getClass().getClassLoader(), rent.getClass().getInterfaces(),this); } //處理代理實例，并返回結(jié)果 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { //動態(tài)代理的本質(zhì)，就是使用反射機制實現(xiàn)！ Object result = method.invoke(rent, args); seeHose(); fee(); return result; } public void seeHose(){ System.out.println("中介帶著看房子！"); } public void fee(){ System.out.println("中介收取費用！"); }}

測試

public class Client { public static void main(String[] args) { //真實角色 Host host = new Host(); //代理角色：現(xiàn)在沒有 ProxyInvocationHandler pih = new ProxyInvocationHandler(); //通過調(diào)用程序處理角色來處理我們要調(diào)用的接口對象！ pih.setRent(host); Rent proxy = (Rent) pih.getProxy(); //這里的proxy就是動態(tài)生成的，我們并沒有寫 proxy.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); } //處理代理實例，并返回結(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+"方法"); }}
- 測試

public class Client { public static void main(String[] args) { //真實角色 UserServiceImpl userService=new UserServiceImpl(); //代理角色，不存在 ProxyInvocationHandler pih=new ProxyInvocationHandler(); pih.setTarget(userService);//要設置成代理的對象 //動態(tài)生成代理類 UserService proxy=(UserService) pih.getProxy(); proxy.query(); }}

動態(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)】

在service包下，定義UserService業(yè)務接口和UserServiceImpl實現(xiàn)類

public interface UserService { public void add(); public void delete(); public void update(); public void select();} 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 select() { System.out.println("查詢了一個用戶！"); }}

在log包下，定義我們的增強類，一個Log前置增強和一個AfterLog后置增強類

public class Log implements MethodBeforeAdvice { //method: 要執(zhí)行的目標對象的方法 //args：參數(shù) //target：目標對象 public void before(Method method, Object[] agrs, Object target) throws Throwable { System.out.println(target.getClass().getName()+"的"+method.getName()+"被執(zhí)行了"); }} public class AfterLog implements AfterReturningAdvice { //returnValue：返回值 public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable { System.out.println("執(zhí)行了"+method.getName()+"方法，返回結(jié)果為："+returnValue); }}

最后去spring的文件中注冊 , 并實現(xiàn)aop切入實現(xiàn) , 注意導入約束，配置applicationContext.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">  <bean id="userService" class="com.kuang.service.UserServiceImpl"/> <bean id="log" class="com.kuang.log.Log"/> <bean id="afterLog" class="com.kuang.log.AfterLog"/>   <aop:config>  <aop:pointcut id="pointcut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>  <aop:advisor advice-ref="log" pointcut-ref="pointcut"/> <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/> </aop:config></beans>

測試

public class MyTest { public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); //動態(tài)代理代理的是接口：注意點 UserService userService = (UserService) context.getBean("userService"); userService.add();// userService.select(); }}

方式二： 自定義類來實現(xiàn)AOP【主要是切面定義】

在diy包下定義自己的DiyPointCut切入類

public class DiyPointCut { public void before(){ System.out.println("=======方法執(zhí)行前========"); } public void after(){ System.out.println("=======方法執(zhí)行后========"); }}

去spring中配置文件

<bean id="diy" class="com.kuang.diy.DiyPointCut"/> <aop:config>  <aop:aspect ref="diy">  <aop:pointcut id="point" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>  <aop:before method="before" pointcut-ref="point"/> <aop:after method="after" pointcut-ref="point"/> </aop:aspect> </aop:config>

測試

與方式一測試一樣

方式三： 使用注解實現(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);}}

在Spring配置文件中，注冊bean，并增加支持注解的配置。

<bean id="annotationPointCut" class="com.kuang.diy.AnnotationPointCut"/>  <aop:aspectj-autoproxy/>

測試

[外鏈圖片轉(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

步驟：

導入相關(guān)jar包

junit
mybatis
mysql數(shù)據(jù)庫
spring相關(guān)的
aop織入器
mybatis-spring【new】
配置Maven靜態(tài)資源過濾問題！

編寫mybatis的配置文件

<dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> </dependency> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.6</version> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.47</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>5.2.0.RELEASE</version> </dependency>   <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>5.2.0.RELEASE</version> </dependency> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.8.13</version> </dependency>  <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis-spring</artifactId> <version>2.0.2</version> </dependency> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <version>1.18.10</version> </dependency> </dependencies> <build> <resources> <resource> <directory>src/main/java</directory> <includes> <include>**/*.properties</include> <include>**/*.xml</include> </includes> <filtering>true</filtering> </resource> </build>

測試

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 需要以下版本：

MyBatis-SpringMyBatisSpring FrameworkSpring BatchJava

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 配置文件中：

注意：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 對象。

現(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：

整合實現(xiàn)一

1、引入Spring配置文件beans.xml

2、配置數(shù)據(jù)源替換mybaits的數(shù)據(jù)源

<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

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> <property name="dataSource" ref="dataSource"/>  <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；

<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">  <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)

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整合！

整合實現(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的配置

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接口新增兩個方法，刪除和增加用戶；

//添加一個用戶 int addUser(User user);//根據(jù)id刪除用戶 int deleteUser(int id);

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事務

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: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)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。

上一篇： MongoDB的安装与可视化工具Stud
下一篇： Mac下将ISO写入U盘镜像

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中的事物管理

總結(jié)

5.1、別名

6.3、擴展方式注入