Java学习笔记11-2——Spring5
生活随笔
收集整理的這篇文章主要介紹了
Java学习笔记11-2——Spring5
小編覺得挺不錯的,現在分享給大家,幫大家做個參考.
文章目錄
- 7.Bean的自動裝配
- 自動裝配說明
- 測試環境搭建
- byName（按名稱自動裝配）
- 測試
- byName運行機制小結：
- byType（按類型自動裝配）
- 測試
- 使用注解進行自動裝配
- @Autowired
- @Qualifier
- @Resource
- @Autowired與@Resource異同
- 8.使用注解開發
- @Component（Bean的實現）
- @Value屬性注入
- @Component的衍生注解
- 注解實現自動裝配
- @scope設置作用域
- 注解開發小結
- 9.使用Java的方式配置Spring
- 10.代理模式
- 靜態代理
- 靜態代理角色分析
- 代碼實現
- 加深理解靜態代理
- 與AOP的關系
- 動態代理
- 例子
- 加深理解
- 11.面向切面編程（AOP）
- 什么是AOP
- AOP在Spring中的作用
- 使用Spring實現Aop
- 方式一：通過 Spring API 實現
- 方式二：自定義類來實現AOP
- 方式三：使用注解實現
- 12.整合Mybatis
- 準備工作
- MyBatis-Spring學習
- Spring整合MyBatis方式一
- Spring整合MyBatis方式二
- 13.聲明式事務
- 代碼演示
7.Bean的自動裝配
自動裝配說明
自動裝配是使用spring滿足bean依賴的一種方法。
spring會在應用上下文中為某個bean尋找其依賴的bean。
Spring中bean有三種裝配機制，分別是：
- 在xml中顯式配置；
- 在java中顯式配置；
- 隱式的bean發現機制和自動裝配。
Spring的自動裝配需要從兩個角度來實現，或者說是兩個操作：
- 組件掃描(component scanning)：spring會自動發現應用上下文中所創建的bean；
- 自動裝配(autowiring)：spring自動滿足bean之間的依賴，也就是我們說的IoC/DI；
組件掃描和自動裝配組合發揮巨大威力，使得顯式的配置降低到最少。
在后面的開發中，推薦不使用自動裝配和xml配置 , 而使用注解
測試環境搭建
1.新建一個項目
2.新建兩個實體類Cat和Dog。都有一個叫的方法
3.新建一個Person類
public class Person {private Cat cat;private Dog dog;private String pname;@Overridepublic String toString() {return "Person{" +"cat=" + cat +", dog=" + dog +", pname='" + pname + '\'' +'}';}public void setCat(Cat cat) {this.cat = cat;}public void setDog(Dog dog) {this.dog = dog;}public void setPname(String pname) {this.pname = pname;}public Cat getCat() {return cat;}public Dog getDog() {return dog;}public String getPname() {return pname;} }4.編寫Spring配置文件
<?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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><bean id="dog" class="pojo.Dog"/><bean id="cat" class="pojo.Cat"/><bean id="person" class="pojo.Person"><property name="cat" ref="cat"/><property name="dog" ref="dog"/><property name="pname" value="張三"/></bean> </beans>5.測試
@Testpublic void testMethodAutowire() {ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");Person person =context.getBean("person",Person.class);person.getCat().shout();person.getDog().shout();}如果測試沒有問題，進入下一步的學習
byName（按名稱自動裝配）
由于在手動配置xml過程中，常常發生字母缺漏和大小寫等錯誤，而無法對其進行檢查，使得開發效率降低。
采用自動裝配將避免這些錯誤，并且使配置簡單化。
測試
1、修改bean配置，增加一個屬性 autowire=“byName”
<bean id="person" class="pojo.Person" autowire="byName"><property name="pname" value="張三"/></bean>2、再次測試，結果依舊成功輸出！
3、我們將 cat 的bean id修改為 cat123
4、再次測試， 執行時報空指針java.lang.NullPointerException。因為按byName規則找不對應set方法，真正的setCat就沒執行，對象就沒有初始化，所以調用時就會報空指針錯誤。
5、但如果將Person類下的方法setCat(Cat cat)改為setCat123(Cat cat)的話又能正常運行，再次印證第4點說明
byName運行機制小結：
當一個bean節點帶有 autowire byName的屬性時。
byType（按類型自動裝配）
使用byType自動裝配時首先需要保證：同一類型的對象，在spring容器中唯一。如果不唯一，會報NoUniqueBeanDefinitionException（bean定義不唯一異常）。
測試
1、將user的bean配置修改一下 ： autowire=“byType”
<bean id="person" class="pojo.Person" autowire="byType"><property name="pname" value="張三"/></bean>2、測試，正常輸出
3、在注冊一個cat 的bean對象！
<bean id="dog" class="pojo.Dog"/><bean id="cat" class="pojo.Cat"/><bean id="cat2" class="pojo.Cat"/>4、測試，報錯：NoUniqueBeanDefinitionException
5、刪掉cat2，將cat的bean名稱改掉，測試。
<bean id="dog" class="pojo.Dog"/><bean id="cat123" class="pojo.Cat"/>因為是按類型裝配，所以并不會報異常，也不影響最后的結果。甚至將id屬性去掉，也不影響結果。
<bean id="dog" class="pojo.Dog"/><bean class="pojo.Cat"/>這就是按照類型自動裝配。
使用注解進行自動裝配
jdk1.5開始支持注解，spring2.5開始全面支持注解。可以利用注解的方式注入屬性。
1、在spring配置文件中引入context文件頭約束
xmlns:context="http://www.springframework.org/schema/context"http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd2、開啟屬性注解支持！
<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/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>@Autowired
該注解和下面的@Qualifier注解屬于org.springframework.beans.factory.annotation
@Autowired是按類型自動轉配的，不支持id匹配。
需要導入 spring-aop的包！
測試：
1、將Person類中的set方法去掉，使用@Autowired注解
public class Person {@Autowiredprivate Cat cat;@Autowiredprivate Dog dog;private String pname;@Overridepublic String toString() {return "Person{" +"cat=" + cat +", dog=" + dog +", pname='" + pname + '\'' +'}';}public void setPname(String pname) {this.pname = pname;}public Cat getCat() {return cat;}public Dog getDog() {return dog;} }此時配置文件內容（因為是按類型自動裝配的，所以cat的bean id改為啥都行）
...<context:annotation-config/><bean id="dog" class="pojo.Dog"/><bean id="cat123" class="pojo.Cat"/>...2、測試成功運行
另外，當@Autowired(required=false)對象可以為null；
當@Autowired(required=true)，對象必須存對象，不能為null。
@Qualifier
@Autowired是根據類型自動裝配的，加上@Qualifier則可以根據byName的方式自動裝配
@Qualifier不能單獨使用。
測試實驗步驟：
1、配置文件修改內容，保證類型存在對象。且名字不為類的默認名字
<bean id="dog1" class="pojo.Dog"/><bean id="dog2" class="pojo.Dog"/><bean id="cat1" class="pojo.Cat"/><bean id="cat2" class="pojo.Cat"/>2、沒有加Qualifier測試，直接報錯
3、在Person屬性上添加Qualifier注解
@Autowired@Qualifier(value = "cat2")private Cat cat;@Autowired@Qualifier(value = "dog2")private Dog dog;4、測試，成功輸出！
@Resource
該注解屬于javax.annotation的
實驗測試：
實驗1：（使之既按名稱查找，也按類型查找）
成功輸出結果
實驗2：（使之按類型查找）
<bean id="dog" class="pojo.Dog"/><bean id="cat1" class="pojo.Cat"/> @Resourceprivate Cat cat;@Resourceprivate Dog dog;同樣成功輸出結果
@Autowired與@Resource異同
1、@Autowired與@Resource都可以用來裝配bean。都可以寫在字段上，或寫在setter方法上。
2、@Autowired默認按類型裝配（屬于spring規范），默認情況下必須要求依賴對象必須存在，如果要允許null 值，可以設置它的required屬性為false，如：@Autowired(required=false) ，如果我們想使用名稱裝配可以結合@Qualifier注解進行使用
3、@Resource默認按照名稱進行裝配，名稱可以通過name屬性進行指定。如果沒有指定name屬性，當注解寫在字段上時，默認取字段名進行按照名稱查找，如果注解寫在setter方法上默認取屬性名進行裝配。當找不到與名稱匹配的bean時才按照類型進行裝配。但是需要注意的是，如果name屬性一旦指定，就只會按照名稱進行裝配。
它們的作用相同都是用注解方式注入對象，但執行順序不同。@Autowired先byType，@Resource先byName。
8.使用注解開發
在spring4之后，必須要保證AOP的包導入
在配置文件當中，還得要引入一個context約束
配置掃描哪些包下的注解
<!--指定注解掃描包--> <context:component-scan base-package="pojo"/>@Component（Bean的實現）
@Component：意為組件，該注解放在類上，說明這個類被Spring管理了，就是bean
<?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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsd"><!--指定注解掃描包--><context:component-scan base-package="pojo"/></beans> @Component // 或者@Component("user") // 相當于配置文件中 <bean id="user" class="當前注解的類"/> public class User {public String name = "張三"; } @Testpublic void test(){ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");User user = (User) applicationContext.getBean("user");System.out.println(user.name);}@Value屬性注入
1、可以不用提供set方法，直接在直接名上添加@value(“值”)
@Value("張三")// 相當于<property name="name" value="張三"/>public String name;2、如果提供了set方法，也可以在set方法上添加@value(“值”)
@Value("張三")// 相當于<property name="name" value="張三"/>public void setName(String name) {this.name = name;}@Component的衍生注解
@Component有幾個衍生注解，我們在Web開發中，會按照MVC三層架構進行分層
- DAO層：@Repository
- Service層：@Service
- Controller層：@Controller
這四個注解的功能是一樣的，都是代表將某個類注冊到Spring中，裝配bean
注解實現自動裝配
上面已講解過
@scope設置作用域
- singleton：默認的，Spring會采用單例模式創建這個對象。關閉工廠 ，所有的對象都會銷毀。
- prototype：原型（多例）模式。關閉工廠 ，所有的對象不會銷毀。內部的垃圾回收機制會回收
該注解放在類上
@Controller("user") @Scope("prototype") public class User {@Value("張三")public String name; }注解開發小結
XML與注解比較
- XML可以適用任何場景 ，結構清晰，維護方便
- 注解不是自己提供的類使用不了，開發簡單方便
xml與注解整合開發 【推薦】：
-
xml管理Bean
-
注解完成屬性注入
作用：
- 進行注解驅動注冊<context:annotation-config/>，從而使注解生效
- 用于激活那些已經在spring容器里注冊過的bean上面的注解，也就是顯式地向Spring注冊
- 如果不掃描包，就需要手動配置bean
- 如果不加注解驅動，則注入的值為null
9.使用Java的方式配置Spring
即完全不使用xml配置
JavaConfig 原來是 Spring 的一個子項目，它通過 Java 類的方式提供 Bean 的定義信息，在 Spring4 的版本， JavaConfig 已正式成為 Spring4 的核心功能 。
測試：
1、編寫一個實體類，Dog
@Component //將這個類標注為Spring的一個組件，放到容器中！ public class Dog {public String name = "dog"; }2、新建一個config配置包，編寫一個MyConfig配置類
@Bean 通過方法注冊一個bean，這里的返回值就Bean的類型，方法名就是bean的id
@Configuration //代表這是一個配置類 public class MyConfig {@Bean //通過方法注冊一個bean，這里的返回值就Bean的類型，方法名就是bean的idpublic Dog dog(){return new Dog();} }3、測試
可以發現這里是通過new AnnotationConfigApplicationContext來讀取Java配置類，對比之前的new ClassPathXmlApplicationContext，之前的是讀取XML配置文件來獲取ApplicationContext
@Test public void test2(){ApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfig.class);Dog dog = (Dog) applicationContext.getBean("dog");System.out.println(dog.name); }4、成功輸出結果
如何導入其他配置類
1、我們再編寫一個配置類！
2、在之前的配置類中我們來選擇導入這個配置類
@Configuration @Import(MyConfig2.class) //導入合并其他配置類，類似于配置文件中的 inculde 標簽 public class MyConfig {@Beanpublic Dog dog(){return new Dog();} }關于這種Java類的配置方式，我們在之后的SpringBoot 和 SpringCloud中還會大量看到，我們需要知道這些注解的作用即可
10.代理模式
為什么要學習代理模式，因為AOP的底層機制就是動態代理！【SpringAOP和SpringMVC】
代理模式包括靜態代理和動態代理
學習AOP之前 , 我們要先了解一下代理模式
靜態代理
以租房為例子
靜態代理角色分析
- 抽象業務：一般使用接口或者抽象類來實現
- 真實角色：被代理的角色
- 代理角色：代理真實角色，代理真實角色后 , 一般會做一些附屬的操作
- 客戶端：使用代理角色來進行一些操作
代碼實現
Rent接口 即租房這一抽象業務
//抽象角色：租房 public interface Rent {void rent(); }Host 即真實角色: 房東，房東要出租房子
//真實角色: 房東，房東要出租房子 public class Host implements Rent{public void rent() {System.out.println("房屋出租");} }Proxy 即代理角色：中介
//代理角色：中介 public class Proxy implements Rent {private Host host;public Proxy() { }public Proxy(Host host) {this.host = host;}//租房public void rent(){seeHouse();host.rent();fee();}//看房public void seeHouse(){System.out.println("帶房客看房");}//收中介費public void fee(){System.out.println("收中介費");} }Client 即客戶端
//客戶類，一般客戶都會去找代理！ public class Client {public static void main(String[] args) {//房東要租房Host host = new Host();//中介幫助房東Proxy proxy = new Proxy(host);//你去找中介proxy.rent();} }靜態代理的好處:
- 可以使得我們的真實角色更加純粹，不再去關注一些公共的事情
- 公共的業務由代理來完成，實現了業務的分工
- 公共業務發生擴展時變得更加集中和方便
缺點 :
- 類多了，多了代理類，工作量變大了，開發效率降低
我們想要靜態代理的好處，又不想要靜態代理的缺點，所以，就有了動態代理
加深理解靜態代理
1、創建一個抽象業務接口（例如UserService），比如平時做的業務，抽象起來就是增刪改查
UserService類似上一例子的租房業務
2、我們需要一個真實對象來完成這些增刪改查操作
真實對象，完成增刪改查操作的人，UserServiceImpl類似上一例子的房東
3、在創建代理角色之前，先想一想，現在我們需要增加一個日志功能，怎么實現？
- 思路1 ：在實現類上增加代碼 【工作量大，效率低下，而且修改公司項目源代碼是大忌】
- 思路2：使用代理來做，能夠不改變原來的業務情況下，實現此功能就是最好的了
4、設置一個代理類進行代理，并實現新增功能
UserServiceProxy相當于上一例子的房屋中介
5、測試訪問類：
public class Client {public static void main(String[] args) {//真實業務UserServiceImpl userService = new UserServiceImpl();//代理類UserServiceProxy proxy = new UserServiceProxy();//使用代理類實現日志功能！proxy.setUserService(userService);proxy.add();} }與AOP的關系
我們在不改變原來的代碼的情況下，實現了對原有功能的增強，這是AOP中最核心的思想
聊聊AOP：縱向開發，橫向開發
動態代理
- 動態代理的角色和靜態代理的一樣
- 動態代理的代理類是動態生成的，靜態代理的代理類是我們提前寫好的
- 動態代理分為兩類：一類是基于接口動態代理，一類是基于類的動態代理
基于接口的動態代理：JDK動態代理
基于類的動態代理：cglib
現在用的比較多的是 javassist 來生成動態代理 . 百度一下javassist
我們這里使用JDK的原生代碼來實現，其余的道理都是一樣的
JDK的動態代理需要了解兩個類
核心 : InvocationHandler 和 Proxy ， 打開JDK幫助文檔看看
【InvocationHandler：調用處理程序】
- proxy 調用該方法的代理實例
- method 所述方法對應于調用代理實例上的接口方法的實例。方法對象的聲明類將是該方法聲明的接口，它可以是代理類繼承該方法的代理接口的父類接口。
- args包含的方法調用傳遞代理實例的參數值的對象的陣列
【Proxy : 代理】
動態代理類 （以下簡稱為代理類 ）是一個實現在類創建時在運行時指定的接口列表的類，具有如下所述的行為。
-
代理接口是由代理類實現的接口。
-
代理實例是代理類的一個實例。
-
每個代理實例都有一個關聯的調用處理程序對象，它實現了接口InvocationHandler 。
-
通過其代理接口之一的代理實例上的方法調用將被分派到實例調用處理程序的invoke方法，傳遞代理實例，java.lang.reflect.Method被調用方法的java.lang.reflect.Method對象以及包含參數的類型Object Object的數組。
-
調用處理程序適當地處理編碼方法調用，并且返回的結果將作為方法在代理實例上調用的結果返回。
例子
抽象業務和真實角色和之前的一樣
Rent 即抽象業務
//抽象業務：租房 public interface Rent {public void rent(); }Host 即真實角色
//真實角色: 房東，房東要出租房子 public class Host implements Rent{public void rent() {System.out.println("房屋出租");} }ProxyInvocationHandler 即代理角色
import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy;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);}// proxy：代理類 method：代理類的調用處理程序的方法對象// 處理代理實例上的方法調用并返回結果@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {seeHouse();//核心：本質利用反射實現Object result = method.invoke(target, args);fee();return result;}//看房public void seeHouse(){System.out.println("帶房客看房");}//收中介費public void fee(){System.out.println("收中介費");} }Client
//租客 public class Client {public static void main(String[] args) {//真實角色Host host = new Host();//代理實例的調用處理程序ProxyInvocationHandler pih = new ProxyInvocationHandler();pih.setTarget(host); //將真實角色放置進去Rent proxy = (Rent)pih.getProxy(); //動態生成對應的代理類proxy.rent();} }一個動態代理 , 一般代理某一類業務 , 一個動態代理可以代理多個類，代理的是接口
加深理解
我們來使用動態代理實現代理我們后面寫的UserService！
我們也可以編寫一個通用的動態代理實現的類！所有的代理對象設置為Object即可！
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);}// proxy : 代理類// method : 代理類的調用處理程序的方法對象.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 methodName){System.out.println("執行了"+methodName+"方法");}}測試！
public class Test {public static void main(String[] args) {//真實對象UserServiceImpl userService = new UserServiceImpl();//代理對象的調用處理程序ProxyInvocationHandler pih = new ProxyInvocationHandler();pih.setTarget(userService); //設置要代理的對象UserService proxy = (UserService)pih.getProxy(); //動態生成代理類！proxy.delete();} }測試，增刪改查，查看結果！
動態代理的好處
靜態代理有的它都有，靜態代理沒有的，它也有
- 可以使得我們的真實角色更加純粹，不再去關注一些公共的事情
- 公共的業務由代理來完成，實現了業務的分工
- 公共業務發生擴展時變得更加集中和方便
- 一個動態代理，一般代理某一類業務
- 一個動態代理可以代理多個類，代理的是接口
11.面向切面編程（AOP）
什么是AOP
AOP（Aspect Oriented Programming）意為：面向切面編程，通過預編譯方式和運行期動態代理實現程序功能的統一維護的一種技術。AOP是OOP的延續，是軟件開發中的一個熱點，也是Spring框架中的一個重要內容，是函數式編程的一種衍生范型。利用AOP可以對業務邏輯的各個部分進行隔離，從而使得業務邏輯各部分之間的耦合度降低，提高程序的可重用性，同時提高了開發的效率。
AOP在Spring中的作用
提供聲明式事務；允許用戶自定義切面
以下名詞需要了解下：
- 橫切關注點：跨越應用程序多個模塊的方法或功能。即是，與我們業務邏輯無關的，但是我們需要關注的部分，就是橫切關注點。如日志，安全，緩存，事務等等
- 切面（Aspect）：橫切關注點 被模塊化 的特殊對象。即，它是一個類。
- 通知（Advice）：切面必須要完成的工作。即，它是類中的一個方法。
- 目標（Target）：被通知對象。
- 代理（Proxy）：向目標對象應用通知之后創建的對象。
- 切入點（PointCut）：切面通知 執行的 “地點”的定義。
- 連接點（JointPoint）：與切入點匹配的執行點。
SpringAOP中，通過Advice定義橫切邏輯，Spring中支持5種類型的Advice：
即 AOP在 不改變原有代碼的情況下，去增加新的功能
使用Spring實現Aop
【重點】使用AOP織入，需要導入一個依賴包！
<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver --> <dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.9.4</version> </dependency>方式一：通過 Spring API 實現
1、首先編寫我們的業務接口和實現類
public interface UserService {public void add();public void delete();public void update();public void search();} public class UserServiceImpl implements UserService{@Overridepublic void add() {System.out.println("增加用戶");}@Overridepublic void delete() {System.out.println("刪除用戶");}@Overridepublic void update() {System.out.println("更新用戶");}@Overridepublic void search() {System.out.println("查詢用戶");} }2、然后去寫我們的增強類 , 我們編寫兩個 , 一個前置增強 一個后置增強
public class Log implements MethodBeforeAdvice {//method : 要執行的目標對象的方法//args : 被調用的方法的參數//target : 目標對象@Overridepublic void before(Method method, Object[] args, Object target) throws Throwable {System.out.println( target.getClass().getName() + "的" + method.getName() + "方法被執行了");} } public class AfterLog implements AfterReturningAdvice {//returnValue 返回值//method被調用的方法//args 被調用的方法的對象的參數//target 被調用的目標對象@Overridepublic void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {System.out.println("執行了" + target.getClass().getName()+"的"+method.getName()+"方法,"+"返回值："+returnValue);} }3、最后去spring的文件中注冊 , 并實現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:aop="http://www.springframework.org/schema/aop"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop.xsd"><!--注冊bean--><bean id="userService" class="service.UserServiceImpl"/><bean id="log" class="log.Log"/><bean id="afterLog" class="log.AfterLog"/><!--aop的配置--><aop:config><!--切入點 expression:表達式匹配要執行的方法--><aop:pointcut id="pointcut" expression="execution(* service.UserServiceImpl.*(..))"/><!--執行環繞; advice-ref執行方法 . pointcut-ref切入點--><aop:advisor advice-ref="log" pointcut-ref="pointcut"/><aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/></aop:config> </beans>4、測試
public class MyTest {@Testpublic void test(){ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");UserService userService = (UserService) context.getBean("userService");userService.search();} }AOP的重要性 : 很重要。一定要理解其中的思路，主要是思想的理解這一塊 .
Spring的AOP就是將公共的業務 (日志 , 安全等) 和領域業務結合起來 , 當執行領域業務時 , 將會把公共業務加進來 . 實現公共業務的重復利用 . 領域業務更純粹 , 程序猿專注領域業務 , 其本質還是動態代理
方式二：自定義類來實現AOP
目標業務類不變依舊是userServiceImpl
1、寫我們自己的一個切入類
public class DiyPointcut {public void before(){System.out.println("---------方法執行前---------");}public void after(){System.out.println("---------方法執行后---------");}}2、去spring中配置（記得注釋掉前一個例子的配置）
<!--第二種方式自定義實現--> <!--注冊bean--> <bean id="diy" class="diy.DiyPointcut"/><!--aop的配置--> <aop:config><!--第二種方式：使用AOP的標簽實現--><aop:aspect ref="diy"><aop:pointcut id="diyPonitcut" expression="execution(* service.UserServiceImpl.*(..))"/><aop:before pointcut-ref="diyPonitcut" method="before"/><aop:after pointcut-ref="diyPonitcut" method="after"/></aop:aspect> </aop:config>execution表達式
execution(* service.UserServiceImpl..*.*(..))
- execution（）：表達式主體
- 第一個 *：表達式返回值類型，*號表示所有的類型
包名：表示需要攔截的包名，后面的兩個句點表示當前包及其子包 - 第二個*：表示類名，*表示所有類
- *(..)：最后這個星號表示 方法名，*表示所有方法，后面括號表示 方法的參數，兩個句點表示所有參數
3、測試：
public class MyTest {@Testpublic void test(){ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");UserService userService = (UserService) context.getBean("userService");userService.add();} }方式三：使用注解實現
1、編寫一個注解實現的增強類
import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.After; import org.aspectj.lang.annotation.Around; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Before;@Aspect public class AnnotationPointcut {@Before("execution(* service.UserServiceImpl.*(..))")public void before(){System.out.println("---------方法執行前---------");}@After("execution(* service.UserServiceImpl.*(..))")public void after(){System.out.println("---------方法執行后---------");}@Around("execution(* service.UserServiceImpl.*(..))")//不常用public void around(ProceedingJoinPoint jp) throws Throwable {System.out.println("環繞前");System.out.println("簽名:"+jp.getSignature());//執行目標方法proceedObject proceed = jp.proceed();System.out.println("環繞后");System.out.println(proceed);} }2、在Spring配置文件中，注冊bean，并增加支持注解的配置（記得注釋掉前面例子的配置）
<!--第三種方式:注解實現--> <bean id="annotationPointcut" class="diy.AnnotationPointcut"/> <aop:aspectj-autoproxy/><aop:aspectj-autoproxy />說明：
通過aop命名空間的<aop:aspectj-autoproxy />聲明自動為spring容器中那些配置@aspectJ切面的bean創建代理，織入切面。當然，spring 在內部依舊采用AnnotationAwareAspectJAutoProxyCreator進行自動代理的創建工作，但具體實現的細節已經被<aop:aspectj-autoproxy />隱藏起來了
<aop:aspectj-autoproxy />有一個proxy-target-class屬性，默認為false，表示使用jdk動態代理織入增強，當配為<aop:aspectj-autoproxy poxy-target-class="true"/>時，表示使用CGLib動態代理技術織入增強。不過即使proxy-target-class設置為false，如果目標類沒有聲明接口，則spring將自動使用CGLib動態代理。
12.整合Mybatis
準備工作
1、導包，配置Maven資源過濾
<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"><parent><artifactId>spring-demo</artifactId><groupId>org.example</groupId><version>1.0-SNAPSHOT</version></parent><modelVersion>4.0.0</modelVersion><artifactId>spring-09-mybatis</artifactId><dependencies><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>5.1.47</version></dependency><dependency><groupId>org.mybatis</groupId><artifactId>mybatis-spring</artifactId><version>2.0.4</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-jdbc</artifactId><version>5.2.3.RELEASE</version></dependency><dependency><groupId>org.mybatis</groupId><artifactId>mybatis</artifactId><version>3.5.2</version></dependency><dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.9.4</version></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><version>1.18.12</version></dependency></dependencies><build><resources><resource><directory>src/main/resources</directory><includes><include>**/*.properties</include><include>**/*.xml</include></includes></resource><resource><directory>src/main/java</directory><includes><include>**/*.properties</include><include>**/*.xml</include></includes><filtering>true</filtering></resource></resources></build></project>2、實體類User
public class User {private int id; //idprivate String name; //姓名private String pwd; //密碼@Overridepublic String toString() {return "User{" +"id=" + id +", name='" + name + '\'' +", pwd='" + pwd + '\'' +'}';} }3、核心配置文件
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configurationPUBLIC "-//mybatis.org//DTD Config 3.0//EN""http://mybatis.org/dtd/mybatis-3-config.dtd"> <configuration><typeAliases><package name="pojo"/></typeAliases><environments default="development"><environment id="development"><transactionManager type="JDBC"/><dataSource type="POOLED"><property name="driver" value="com.mysql.cj.jdbc.Driver"/><property name="url" value="jdbc:mysql://localhost:3306/mybatis?userSSL=true&useUnicode=true&characterEncoding=UTF8&serverTimezone=UTC"/><property name="username" value="root"/><property name="password" value="123456"/></dataSource></environment></environments><mappers><mapper resource="UserMapper.xml"/></mappers> </configuration>4、UserDao接口編寫
public interface UserMapper {List<User> selectUser(); }5、接口對應的Mapper映射文件
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapperPUBLIC "-//mybatis.org//DTD Mapper 3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace="dao.UserMapper"><select id="selectUser" resultType="User">select * from user;</select></mapper>6、測試
public class MyTest {@Testpublic void selectUser() throws IOException {String resource = "mybatis-config.xml";InputStream inputStream = Resources.getResourceAsStream(resource);SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);SqlSession sqlSession = sqlSessionFactory.openSession(true);UserMapper mapper = sqlSession.getMapper(UserMapper.class);List<User> userList = mapper.selectUser();for (User user: userList){System.out.println(user);}sqlSession.close();} }MyBatis-Spring學習
Spring整合MyBatis方式一
1、引入Spring配置文件Spring-dao.xml（名字隨便起）最后導入到applicationContext.xml 測試中就可以直接這個applicationContext.xml
2、配置數據源替換mybaits的數據源
mybatis-config.xml
3、配置SqlSessionFactory，關聯MyBatis
4、注冊sqlSessionTemplate，關聯sqlSessionFactory；
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/beanshttps://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/aophttps://www.springframework.org/schema/aop/spring-aop.xsd"><!--DataSource 使用Spring的數據源替換Mybatis的配置--><!--配置數據源：可以使用第三方的，也可使用Spring的 這里使用Spring提供的JDBC--><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/jdbcstudy?serverTimezone=UTC&useUnicode=true&characterEncoding=utf8&useSSL=true"/><property name="username" value="root"/><property name="password" value="123456"/></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:UserMapper.xml"/>不需要寫，因為上面那行綁定的mybatis-config.xml里面已經包含綁定了UserMapper.xml，兩種只能選其一種--></bean><!--SqlSessionTemplate就是我們使用的sqlSession --><bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate"><!--只能使用構造器注入sqlSessionFactory，因為它沒有set方法--><constructor-arg index="0" ref="sqlSessionFactory"/></bean></beans>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/beanshttps://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/aophttps://www.springframework.org/schema/aop/spring-aop.xsd"><import resource="spring-dao.xml"/><bean id="userMapper" class="dao.UserMapperImpl"><property name="sqlSession" ref="sqlSession"/></bean></beans>5、增加Dao接口的實現類；私有化sqlSessionTemplate
public class UserMapperImpl implements UserMapper{// 在原來，我們所有操作都使用sqlSession來執行，現在都使用sqlSessionTemplateprivate SqlSessionTemplate sqlSession;// 之前用習慣sqlSession，故取名為sqlSessionpublic void setSqlSession(SqlSessionTemplate sqlSession) {this.sqlSession = sqlSession;}public List<User> selectUser() {UserMapper mapper = sqlSession.getMapper(UserMapper.class);return mapper.selectUser();}}6、測試
public class MyTest {@Testpublic void test2(){ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");UserMapper mapper = (UserMapper) context.getBean("userMapper");List<User> user = mapper.selectUser();System.out.println(user);} }Spring整合MyBatis方式二
mybatis-spring1.2.3版以上的才有這個 .
官方文檔截圖 :
dao繼承Support類 , 直接利用 getSqlSession() 獲得 , 然后直接注入SqlSessionFactory . 比起方式1 , 不需要管理SqlSessionTemplate , 而且對事務的支持更加友好 . 可跟蹤源碼查看
1、將我們上面寫的UserMapperImpl修改一下
public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper {public List<User> selectUser() {UserMapper mapper = getSqlSession().getMapper(UserMapper.class);return mapper.selectUser();} }2、修改bean的注冊
<bean id="userMapper2" class="dao.UserMapperImpl2"><property name="sqlSessionFactory" ref="sqlSessionFactory"/></bean>3、測試
@Testpublic void test3(){ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");UserMapper mapper = (UserMapper) context.getBean("userMapper2");List<User> user = mapper.selectUser();System.out.println(user);}13.聲明式事務
要么都成功，要么都失敗
事務的ACID原則：
- 原子性
- 一致性
- 隔離性
多個業務可能操作一個資源，防止數據損壞 - 持久性
事務一旦提交，無論系統發生什么問題，結果都不會被影響。
Spring中的事務管理
- 聲明式事務（AOP的一個應用，交由容器管理）
- 編程式事務
代碼演示
spring-dao.xml
需要導入tx約束
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"xsi:schemaLocation="http://www.springframework.org/schema/beanshttps://www.springframework.org/schema/beans/spring-beans.xsd"><import resource="spring-dao.xml"/><bean id="userMapper" class="dao.UserMapperImpl"><property name="sqlSessionFactory" ref="sqlSessionFactory"></property></bean></beans>UserMapper接口
public interface UserMapper {List<User> selectUser();// 添加一個用戶int addUser(User user);// 刪除一個用戶int deleteUser(int id); }UserMapper.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapperPUBLIC "-//mybatis.org//DTD Mapper 3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace="dao.UserMapper"><select id="selectUser" resultType="User">select * from mybatis.user;</select><insert id="addUser" parameterType="user">insert into mybatis.user (id, name, pwd) values(#{id}, #{name}, #{pwd});</insert><delete id="deleteUser" parameterType="int">delete from mybatis.user where id=#{id};</delete></mapper>UserMapper實現類UserMapperImpl
public class UserMapperImpl extends SqlSessionDaoSupport implements UserMapper {public List<User> selectUser() {User user = new User(10, "王五123", "213123");SqlSession sqlSession = getSqlSession();UserMapper mapper = sqlSession.getMapper(UserMapper.class);mapper.addUser(user);mapper.deleteUser(6);return mapper.selectUser();}public int addUser(User user) {return getSqlSession().getMapper(UserMapper.class).addUser(user);}@Overridepublic int deleteUser(int id) {return getSqlSession().getMapper(UserMapper.class).deleteUser(id);}}測試
@Testpublic void test(){ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");UserMapper mapper = context.getBean("userMapper",UserMapper.class);List<User> userList = mapper.selectUser();for(User user:userList){System.out.println(user);}}為什么需要配置事務？
- 如果不配置，就需要我們手動提交控制事務
- 事務在項目開發過程非常重要，涉及到數據的一致性的問題，不容馬虎！
總結
以上是生活随笔為你收集整理的Java学习笔记11-2——Spring5的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： api-gateway实践（03）新服务
- 下一篇： Java学习笔记7-1——注解与反射