Spring詳解

wangyudong927發表於2022-03-27

1、Spring

1.1、簡介

Spring：春天------>給軟體行業帶來了春天！
2002，首次推出了Spring框架的雛形：interface21框架！
Spring框架即以interface21框架為基礎,經過重新的設計,並不斷的豐富其內涵,於2004年3月24日,釋出了1.0正式版。
Rod Johnson ，Spring Framework創始人，著名作者。很難想象Rod Johnson的學歷，真的讓好多人大吃一驚，他是悉尼大學的博士，然而他的專業不是計算機，而是音樂學。
spring理念：使現有的技術更加容易使用，本身是一個大雜燴，整合了現有的技術框架！
SSH ：Struct2 + Spring + Hibernate！
SSM ：SpringMVC + Spring + Mybatis！

官網：https://docs.spring.io/spring-framework/docs/current/reference/html/overview.html#overview

官方下載地址：https://repo.spring.io/ui/native/release/org/springframework/spring

GitHub：https://github.com/spring-projects/spring-framework

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.17</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.3.17</version>
</dependency>

1.2、優點

Spring是一個開源的免費的框架（容器）！
Spring是一個輕量級的、非入侵式的框架！
控制反轉（IOC），面向切面程式設計（AOP）！
支援事務的處理，對框架整合的支援！

總結一句話：Spring就是一個輕量級的控制反轉（IOC）和麵向切面程式設計（AOP）的框架！

1.3、組成

1.4、擴充

在Spring的官網有這個介紹：現代化的Java開發！說白就是基於Spring開發！

Spring Boot
- 一個快速開發的腳手架。
- 基於SpringBoot可以快速的開發單個微服務。
- 約定大於配置！
Spring Cloud
- Spring Cloud是基於Spring Boot實現的。

因為現在大多數公司都在使用SpringBoot進行快速開發，學習SpringBoot的前提，需要完全掌握Spring及SpringMVC！承上啟下的作用！

弊端：發展了太久之後，違背了原來的理念！配置十分繁瑣，人稱：“配置地獄！”

2、IOC理論推導

UserDao 介面
UserDaoImpl 實現類
UserService 業務介面
UserServiceImpl 業務實現類

在我們之前的業務中，使用者的需求可能會影響我們原來的程式碼，我們需要根據使用者的需求去修改原始碼！如果程式程式碼量十分大，修改一次的成本代價十分昂貴！

我們使用一個Set介面實現。已經發生了革命性的變化！

private UserDao userDao;

//利用set進行動態實現值的注入！
public void setUserDao(UserDao userDao) {
    this.userDao = userDao;
}
=========================================
public static void main(String[] args) {
    
    //使用者實際呼叫的是業務層，dao層它們不需要接觸！
    UserService userService = new UserServiceImpl();
    ((UserServiceImpl) userService).setUserDao(new UserDaoMysqlImpl());
    userService.getUser();
}

之前，程式是主動建立物件！控制權在程式設計師手上！
使用了set注入後，程式不再具有主動性，而是變成了被動的接收物件！

這種思想，從本質上解決了問題，我們程式設計師不用再去管理物件的建立了。系統的耦合性大大降低~。可以更加專注在業務的實現上！這是IOC的原型！

IOC本質

控制反轉IoC(Inversion of Control)，是一種設計思想，DI(依賴注入)是實現IoC的一種方法，也有人認為DI只是IoC的另一種說法。沒有IoC的程式中，我們使用物件導向程式設計，物件的建立與物件間的依賴關係完全硬編碼在程式中，物件的建立由程式自己控制，控制反轉後將物件的建立轉移給第三方，個人認為所謂控制反轉就是：獲得依賴物件的方式反轉了。

採用XML方式配置Bean的時候，Bean的定義資訊是和現實分離的，而採用註解的方式可以把兩者合為一體，Bean的定義資訊直接以註解的形式定義在實現類中，從而達到了零配置的目的。

控制反轉是一種通過描述（XML或註解）並通過第三方去生產或獲取特定物件的方式。在Spring中實現控制反轉的是IoC容器，其實現方法是依賴注入（Dependency Injection,DI）。

3、HelloSpring

匯入Jar包

注：spring需要匯入commons-logging進行日誌記錄，我們利用maven，它會自動下載對應的依賴項

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.17</version>
</dependency>

編寫程式碼

編寫第一個Hello實體類

public class Hello {
    private String str;

    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }

    @Override
    public String toString() {
        return "Hello{" +
                "str='" + str + '\'' +
                '}';
    }
}

編寫我們的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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--
	bean就是java物件，由Spring建立和管理
	使用Spring來建立物件，在Spring這些都成為Bean

    型別 變數名 = new 型別();
    Hello hello = new Hello();
    bean = 物件    new Hello();

    id = 變數名
    class = new 的物件；
    property 相當於給物件中的屬性設定一個值！

    -->
    <bean id="hello" class="com.kuang.pojo.Hello">
        <property name="str" value="Spring"/>
    </bean>

</beans>

我們可以去進行測試了

public class MyTest {
    public static void main(String[] args) {
        //獲取Spring的上下文物件！
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //我們的物件現在都在Spring中管理了，我們要使用，直接去裡面取出來就可以！
        Hello hello = (Hello) context.getBean("hello");

        System.out.println(hello.toString());
    }
}

思考

Hello物件是誰建立的？ hello物件是由Spring建立的
Hello物件的屬性是怎麼設定的？hello物件的屬性是由Spring容器設定的

這個過程就叫控制反轉：

控制：誰來控制物件的建立，傳統應用程式的物件是由程式本身控制建立的，使用Spring後，物件是由Spring來建立的
反轉：程式本身不建立物件，而變成被動的接收物件

依賴注入：就是利用set方法來進行注入的。

IOC是一種程式設計思想，由主動的程式設計程式設計被動的接收

可以通過newClassPathXmlApplicationContext去瀏覽一下底層原始碼。

4、IOC建立物件的方式

使用無參構造建立物件，預設！

假設我們要使用有參構造建立物件。

下標賦值

<!--第一種，下標賦值！-->
<bean id="user" class="com.kuang.pojo.User">
    <constructor-arg index="0" value="狂神說Java"/>
</bean>

型別

<!--第二種方式：通過型別建立，不建議使用-->
<bean id="user" class="com.kuang.pojo.User">
    <constructor-arg type="java.lang.String" value="qinjiang"/>
</bean>

引數名

<!--第三種，直接通過引數名來設定-->
<bean id="user" class="com.kuang.pojo.User">
    <constructor-arg name="name" value="秦疆"/>
</bean>

總結：在配置檔案載入的時候，容器中管理的物件就已經初始化了

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，一般用於團隊開發使用，它可以將多個配置檔案，匯入合併為一個

假設，現在專案中有多個人開發，這三個人負責不同的類開發，不同的類需要註冊在不同的bean中，我們可以利用import，將所有人的beans.xml合併為一個總的！

張三
李四
王五

applicationContext.xml

<import resource="beans.xml"/>
<import resource="beans2.xml"/>
<import resource="beans3.xml"/>

使用的時候，直接使用總的配置就可以了

6、DI依賴注入

6.1、構造器注入

前面已經說過了

6.2、Set方式注入【重點】

依賴注入：Set注入！
- 依賴：bean物件的建立依賴於容器
- 注入：bean物件中的所有屬性，由容器來注入！

【環境搭建】

複雜型別

public class Address {

    private String address;
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
}

真實測試物件

public class Student {

    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbys;
    private Map<String,String> card;
    private Set<String> games;
    private String wife;
    private Properties info;
    ......
}

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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="student" class="com.kuang.pojo.Student">
        <!--第一種，普通值注入，value-->
        <property name="name" value="qinjiang"/>
    </bean>

</beans>

測試類

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());
    }
}

完善注入資訊

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="address" class="com.kuang.pojo.Address">
        <property name="address" value="西安"/>
    </bean>

    <bean id="student" class="com.kuang.pojo.Student">
        <!--第一種，普通值注入，value-->
        <property name="name" value="qinjiang"/>

        <!--第二種，Bean注入，ref-->
        <property name="address" ref="address"/>

        <!--陣列-->
        <property name="books">
            <array>
                <value>紅樓夢</value>
                <value>三國演義</value>
                <value>水滸傳</value>
                <value>西遊記</value>
            </array>
        </property>

        <!--List-->
        <property name="hobbys">
            <list>
                <value>聽歌</value>
                <value>敲程式碼</value>
                <value>看電影</value>
            </list>
        </property>

        <!--Map-->
        <property name="card">
            <map>
                <entry key="身份證" value="111111222222223333"/>
                <entry key="銀行卡" value="123123123123123123"/>
            </map>
        </property>

        <!--Set-->
        <property name="games">
            <set>
                <value>LOL</value>
                <value>COC</value>
                <value>BOB</value>
            </set>
        </property>

        <!--null-->
        <property name="wife">
            <null/>
        </property>

        <!--Properties-->
        <property name="info">
            <props>
                <prop key="driver">20190525</prop>
                <prop key="url">男</prop>
                <prop key="username">root</prop>
                <prop key="password">123456</prop>
            </props>
        </property>
    </bean>

</beans>

6.3、擴充方式注入

我們可以使用p名稱空間和c名稱空間進行注入

官方解釋：

使用：

<?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:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--p名稱空間注入，可以直接注入屬性的值：property-->
    <bean id="user" class="com.kuang.pojo.User" p:name="qinjiang" p:age="18"/>

    <!--c名稱空間注入，通過構造器注入：constructor-args-->
    <bean id="user2" class="com.kuang.pojo.User" c:age="18" c:name="kuangshen"/>

</beans>

測試：

@Test
public void test2(){
    ApplicationContext context = new ClassPathXmlApplicationContext("userbean.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的作用域

單例模式（Spring預設機制）

<bean id="user2" class="com.kuang.pojo.User" c:age="18" c:name="kuangshen" scope="singleton"/>

原型模式：每次從容器中get的時候，都會產生一個新物件！

<bean id="accountService" class="com.something.DefaultAccountService" scope="prototype"/>

其餘的request、session、application這些個只能在web開發中使用到！

7、Bean的自動裝配

自動裝配是Spring滿足bean依賴的一種方式！
Spring會在上下文中自動尋找，並自動給bean裝配屬性！

在Spring中有三種裝配的方式

在xml中顯示的配置
在java中顯示配置
隱式的自動裝配bean 【重要】

7.1、測試

環境搭建
- 一個人有兩個寵物！

7.2、ByName自動裝配

<!--
    byName: 會自動在容器上下文查詢，和自己物件set方法後面的值對應的 beanid！
    -->
<bean id="people" class="com.kuang.pojo.People" autowire="byName">
    <property name="name" value="kuangshen"/>
</bean>

7.3、ByType自動裝配

<bean class="com.kuang.pojo.Cat"/>
<bean class="com.kuang.pojo.Dog"/>

<!--
    byName: 會自動在容器上下文查詢，和自己物件set方法後面的值對應的 beanid！
    byType: 會自動在容器上下文查詢，和自己物件屬性型別相同的bean！
    -->
<bean id="people" class="com.kuang.pojo.People" autowire="byType">
    <property name="name" value="kuangshen"/>
</bean>

小結：

byname的時候，需要保證所有bean的id唯一，並且這個bean需要和自動注入的屬性的set方法的值一致！
bytype的時候，需要保證所有bean的class唯一，並且這個bean需要和自動注入的屬性的型別一致！

7.4、使用註解實現自動裝配

jdk1.5支援的註解，Spring2.5就支援註解了！

The introduction of annotation-based configuration raised the question of whether this approach is “better” than XML.

要使用註解須知：

匯入約束：context約束

配置註解的支援：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>

@Autowired

直接在屬性上使用即可！也可以在set方法上使用！

使用Autowired我們可以不用編寫Set方法了，前提是你這個自動裝配的屬性在IOC（Spring）容器中存在，通過byType，再通過byname查詢！

科普：

@Nullable    欄位標記了這個註解，說明這個欄位可以為null；

public @interface Autowired {
    boolean required() default true;
}

測試程式碼

public class People {

    private String name;
    @Autowired
    private Dog dog;
    //如果顯示定義了Autowired的required屬性為false，說明這個物件可以為null，否則不允許為空
    @Autowired(required = false)
    private Cat cat;
}

如果@Autowired自動裝配的環境比較複雜，自動裝配無法通過一個註解【@Autowired】完成的時候，我們可以使用@Qualifier(value="xxx")去配合@Autowired的使用，指定一個唯一的bean物件注入！

public class People {

    private String name;
    @Autowired
    @Qualifier(value="dog222")
    private Dog dog;
    //如果顯示定義了Autowired的required屬性為false，說明這個物件可以為null，否則不允許為空
    @Autowired
    private Cat cat;
}

@Resource註解

public class People {
    
    private String name;
    @Resource(name="dog222")
    private Dog dog;
    //如果顯示定義了Autowired的required屬性為false，說明這個物件可以為null，否則不允許為空
    @Resource
    private Cat cat;
}

小結：

@Resource和@Autowired的區別：

都是用來自動裝配的，都可以放在屬性欄位上
@Autowired通過byType方式實現，再通過byname查詢，必須要求這個物件存在！ 【常用】
@Resource 預設通過byname的方式實現，如果找不到名字在，則通過byType實現！如果兩個都找不到的情況下，就報錯！
執行順序不同：@Autowired通過byType方式實現。@Resource 預設通過byname的方式實現。

8、使用註解開發

在Spring4之後，要使用註解開發，必須要保證aop的包匯入了

使用註解需要匯入context約束，增加註解的支援！

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        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

屬性如何注入

@Component
public class User {

    public String name;

    //相當於 <property name="name" value="kuangshen"/>
    @Value("kuangshen")
    public void setName(String name) {
        this.name = name;
    }
}

衍生的註解

@Component 有幾個衍生註解，我們在web開發中，會按照mvc三層架構分層！
- dao 【@Repository】
- service 【@Service】
- controller 【@Controller】
  
  這四個註解功能都是一樣的，都是代表將某個類註冊到Spring中，裝配Bean

自動裝配

- @Autowired : 自動裝配通過型別，然後名字
    如果Autowired不能唯一裝配上屬性，則需要通過@Qualifier(value="xxx")
- @Nullable    欄位標記了這個註解，說明這個欄位可以為null；
- @Resource  : 自動裝配通過名字，然後型別
- @Component : 元件，放在類上，說明這個類被Spring管理了，就是bean！

作用域

@Component
@Scope("prototype")
public class User {


    public String name;

    //相當於 <property name="name" value="kuangshen"/>
    @Value("kuangshen")
    public void setName(String name) {
        this.name = name;
    }
}

小結

xml與註解：
- xml更加萬能，適用於任何場合！維護簡單方便
- 註解不是自己的類使用不了，維護相對複雜！
xml 與註解最佳實踐：
- xml用來管理bean；
- 註解只負責完成屬性的注入；
- 我們在使用的過程中，只需要注意一個問題：必須讓註解生效，就需要開啟註解的支援
```

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

9、使用Java的方式配置Spring

我們現在要完全不使用Spring的xml配置了，全權交給Java來做！

JavaConfig 是Spring的一個子專案，在Spring 4 之後，它成為了一個核心功能！

實體類：

//這裡這個註解的意思，就是說明這個類被Spring接管了，註冊到了容器中
@Component
public class User {
    private String name;

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }

    public String getName() {
        return name;
    }

    @Value("qinjiang") //屬性注入值
    public void setName(String name) {
        this.name = name;
    }
}

配置檔案：

package com.kuang.config;

import com.kuang.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

// 這個也會被Spring容器託管，註冊到容器中，因為它本來就是一個@Component
// @Configuration代表這是一個配置類，就和我們之前看的beans.xml是一樣的
@Configuration
@ComponentScan("com.kuang.pojo")
@Import(KuangConfig2.class)
public class KuangConfig {

    //註冊一個bean ，就相當於我們之前寫的一個bean標籤
    //這個方法的名字 ，就相當於bean標籤中的id屬性
    //這個方法的返回值 ，就相當於bean標籤中的class屬性
    @Bean
    public User user(){
        return new User(); //就是返回要注入到bean的物件！
    }
}

測試類！

public class MyTest {
    public static void main(String[] args) {
        //如果完全使用了配置類方式去做，我們就只能通過 AnnotationConfig 上下文來獲取容器，通過配置類的class物件載入！
        ApplicationContext context = new AnnotationConfigApplicationContext(KuangConfig.class);
        User user = (User) context.getBean("user");

        System.out.println(user.getName());
    }
}

這種純Java的配置方式，在SpringBoot中隨處可見！

10、代理模式

為什麼要學習代理模式？因為這就是SpringAOP的底層！【SpringAOP 和 SpringMVC】

代理模式的分類：

靜態代理
動態代理

10.1、靜態代理（例：房東出租房子）

角色分析：

抽象角色：一般會使用介面或者抽象類來解決
真實角色：被代理的角色
代理角色：代理真實角色，代理真實角色後，我們一般會做一些附屬操作
客戶：訪問代理物件的人！

程式碼步驟：

介面

//租房
public interface Rent {
    public void rent();
}

真實角色

//房東
public class Host implements Rent{

    @Override
    public void rent() {
        System.out.println("房東要出租房子！");
    }
}

代理角色

public class Proxy implements Rent{

    private Host host;

    public Proxy() {
    }

    public Proxy(Host host){
        this.host=host;
    }

    @Override
    public void rent() {
        seeHouse();
        host.rent();
        hetong();
        fare();
    }

    //看房
    public void seeHouse(){
        System.out.println("中介帶你看房");
    }

    //籤合同
    public void hetong(){
        System.out.println("籤租賃合同");
    }

    //收中介費
    public void fare(){
        System.out.println("收中介費");
    }
}

客戶端訪問代理角色

public class Client {

    public static void main(String[] args) {
        //房東要租房子
        Host host = new Host();
        //代理，中介幫房東租房子，但是呢？代理一般會有一些附屬操作！
        Proxy proxy = new Proxy(host);

        //你不用面對房東，直接找中介租房即可！
        proxy.rent();
    }
}

代理模式的好處：

可以使真實角色的操作更加純粹！不用去關注一些公共的業務
公共業務就交給代理角色！實現了業務的分工！
公共業務發生擴充套件的時候，方便集中管理！

缺點：

一個真實角色就會產生一個代理角色；程式碼量會翻倍_{開發效率會變低}

10.2、加深理解

程式碼：對應 08-demo02；

public interface UserService {
    void add();
    void delete();
    void update();
    void query();
}
==============================================
//真實物件
public class UserServiceImpl implements UserService{
    @Override
    public void add() {
        System.out.println("增加了一個使用者");
    }

    @Override
    public void delete() {
        System.out.println("刪除了一個使用者");
    }

    @Override
    public void update() {
        System.out.println("修改了一個使用者");
    }

    @Override
    public void query() {
        System.out.println("查詢了一個使用者");
    }

    //1.改動原有的業務程式碼，在公司中是大忌
}
==============================================
public class UserServiceProxy implements UserService{

    private UserServiceImpl userserviceimpl;

    public UserServiceImpl getUserserviceimpl() {
        return userserviceimpl;
    }

    public void setUserserviceimpl(UserServiceImpl userserviceimpl) {
        this.userserviceimpl = userserviceimpl;
    }

    @Override
    public void add() {
        log("add");
        userserviceimpl.add();
    }

    @Override
    public void delete() {
        log("delete");
        userserviceimpl.delete();
    }

    @Override
    public void update() {
        log("update");
        userserviceimpl.update();
    }

    @Override
    public void query() {
        log("query");
        userserviceimpl.query();
    }

    //日誌方法
    public void log(String msg){
        System.out.println("[Debug] 使用了"+msg+"方法");
    }
}
===============================================
public class Client {

    public static void main(String[] args) {
        UserServiceImpl userserviceimpl = new UserServiceImpl();
        UserServiceProxy proxy = new UserServiceProxy();

        proxy.setUserserviceimpl(userserviceimpl);

        proxy.add();
    }
}

聊聊AOP

10.3、動態代理

動態代理和靜態代理角色一樣
動態代理的代理類是動態生成的，不是我們直接寫好的！
動態代理分為兩大類：基於介面的動態代理，基於類的動態代理
- 基於介面---JDK動態代理【我們在這裡使用】
- 基於類：cglib
- java位元組碼實現：javassist

需要了解兩個類：Proxy：代理，InvocationHandler：呼叫處理程式

動態代理的好處：

可以使真實角色的操作更加純粹！不用去關注一些公共的業務
公共業務就交給代理角色！實現了業務的分工！
公共業務發生擴充套件的時候，方便集中管理！
一個動態代理類代理的是一個介面，一般就是對應的一類業務
一個動態代理類可以代理多個類，只要是實現了同一個介面即可！

程式碼：

//租房
public interface Rent {
    public void rent();
}
===========================================
//房東
public class Host implements Rent {

    @Override
    public void rent() {
        System.out.println("房東要出租房子！");
    }
}
============================================
//等會我們會用這個類，自動生成代理類！
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);
    }

    //處理代理例項，並返回結果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        //動態代理的本質，就是使用反射機制實現！
        seeHouse();
        Object result = method.invoke(rent, args);
        fare();
        return result;

    }

    public void seeHouse(){
        System.out.println("中介帶看房子");
    }
    public void fare(){
        System.out.println("收中介費");
    }
}
====================================================
public class Client {
    public static void main(String[] args) {
        //真實角色
        Host host = new Host();

        //代理角色：現在沒有
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        //通過呼叫程式處理角色來處理我們要呼叫的介面物件！
        pih.setRent(host);
        Rent proxy = (Rent) pih.getProxy();//這裡的proxy就是動態生成的，我們並沒有寫！
        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);
    }

    //處理代理例項，並返回結果
    @Override
    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("執行了"+msg+"方法");
    }
}
=============================================================
public class Client {
    public static void main(String[] args) {
        //真實角色
        UserServiceImpl userService = new UserServiceImpl();
        //代理角色，不存在
        ProxyInvocationHandler pih = new ProxyInvocationHandler();

        pih.setTarget(userService);//設定要代理的物件
        //動態生成代理類
        UserService proxy = (UserService) pih.getProxy();

        proxy.query();

    }
}

11、AOP

11.1、什麼是AOP

AOP（Aspect Oriented Programming）意為：面向切面程式設計，通過預編譯方式和執行期動態代理實現程式功能的統一維護的一種技術。AOP是OOP的延續，是軟體開發中的一個熱點，也是Spring框架中的一個重要內容，是函數語言程式設計的一種衍生範型。利用AOP可以對業務邏輯的各個部分進行隔離，從而使得業務邏輯各部分之間的耦合度降低，提高程式的可重用性，同時提高了開發的效率。

11.2、AOP在Spring中的作用

提供宣告式事務；允許使用者自定義切面

橫切關注點：跨越應用程式多個模組的方法或功能。即是，與我們業務邏輯無關的，但是我們需要關注的部分，就是橫切關注點。如日誌 , 安全 , 快取 , 事務等等 ....
切面（ASPECT）：橫切關注點被模組化的特殊物件。即，它是一個類。
通知（Advice）：切面必須要完成的工作。即，它是類中的一個方法。
目標（Target）：被通知物件。
代理（Proxy）：向目標物件應用通知之後建立的物件。
切入點（PointCut）：切面通知執行的 “地點”的定義。
連線點（JointPoint）：與切入點匹配的執行點。

SpringAOP中，通過Advice定義橫切邏輯，Spring中支援5種型別的Advice:

即 AOP 在不改變原有程式碼的情況下 , 去增加新的功能。

11.3、使用Spring實現AOP

【重點】使用AOP注入，需要匯入一個依賴包！

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.9</version>
</dependency>

方式一：使用Spring的API介面【主要是SpringAPI介面實現】

<?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-->
    <bean id="userService" class="com.kuang.service.UserServiceImpl"/>
    <bean id="afterLog" class="com.kuang.log.AfterLog"/>
    <bean id="log" class="com.kuang.log.Log"/>

    <!--方式一:使用原生Spring API介面-->
    <!--配置aop:需要匯入aop的約束-->
    <aop:config>
        <!--切入點：expression:表示式，execution(要執行的位置！ * * * * *) 修飾詞 類 方法名 引數-->
        <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 interface UserService {

    void add();
    void delete();
    void update();
    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("查詢了一個使用者");
    }
}
=============================================
public class AfterLog implements AfterReturningAdvice {
    //returnValue;返回值
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("執行了"+method.getName()+"方法，返回結果為："+returnValue);
    }
}
==============================================
public class Log implements MethodBeforeAdvice {

    //method: 要執行的目標物件的方法
    //object: 引數
    //target: 目標物件
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"的"+method.getName()+"被執行了");
    }
}
==============================================
public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //動態代理代理的是介面:注意點
        UserService userService = context.getBean("userService", UserService.class);

        userService.add();
    }
}

方式二：自定義類來實現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/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-->
    <bean id="userService" class="com.kuang.service.UserServiceImpl"/>
    <bean id="afterLog" class="com.kuang.log.AfterLog"/>
    <bean id="log" class="com.kuang.log.Log"/>

    <!--方式一:使用原生Spring API介面-->
    <!--配置aop:需要匯入aop的約束-->
<!--    <aop:config>-->
<!--        &lt;!&ndash;切入點：expression:表示式，execution(要執行的位置！ * * * * *) 修飾詞 類 方法名 引數&ndash;&gt;-->
<!--        <aop:pointcut id="pointcut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>-->
<!--        &lt;!&ndash;執行環繞增加!&ndash;&gt;-->
<!--        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>-->
<!--        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>-->
<!--    </aop:config>-->

    <!--方式二: 自定義類-->
    <bean id="diy" class="com.kuang.diy.DiyPointCut"/>

    <aop:config>
        <!--自定義切面, ref 要引用的類-->
        <aop:aspect ref="diy">
        <!--切入點  execution(返回型別 包名(類名) 方法名)-->
        <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>

</beans>

public class DiyPointCut {

    public void before(){
        System.out.println("=========方法執行前=========");
    }
    public void after(){
        System.out.println("=========方法執行後=========");
    }
}
============================================================
public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //動態代理代理的是介面:注意點
        UserService userService = context.getBean("userService", UserService.class);

        userService.add();
    }
}

方式三：使用註解實現！

<?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-->
    <bean id="userService" class="com.kuang.service.UserServiceImpl"/>
    <bean id="afterLog" class="com.kuang.log.AfterLog"/>
    <bean id="log" class="com.kuang.log.Log"/>

    <!--方式三：-->
    <bean id="annotationPointCut" class="com.kuang.diy.AnnotationPointCut"/>
    <!--開啟註解支援！ JDK(預設 proxy-target-class="false") cglib(proxy-target-class="true")-->
    <aop:aspectj-autoproxy proxy-target-class="false"/>


    <!--方式一:使用原生Spring API介面-->
    <!--配置aop:需要匯入aop的約束-->
<!--    <aop:config>-->
<!--        &lt;!&ndash;切入點：expression:表示式，execution(要執行的位置！ * * * * *) 修飾詞 類 方法名 引數&ndash;&gt;-->
<!--        <aop:pointcut id="pointcut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>-->
<!--        &lt;!&ndash;執行環繞增加!&ndash;&gt;-->
<!--        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>-->
<!--        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>-->
<!--    </aop:config>-->

    <!--方式二: 自定義類-->
<!--    <bean id="diy" class="com.kuang.diy.DiyPointCut"/>-->

<!--    <aop:config>-->
<!--        &lt;!&ndash;自定義切面, ref 要引用的類&ndash;&gt;-->
<!--        <aop:aspect ref="diy">-->
<!--        &lt;!&ndash;切入點  execution(返回型別 包名(類名) 方法名)&ndash;&gt;-->
<!--        <aop:pointcut id="point" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>-->
<!--        &lt;!&ndash;通知&ndash;&gt;-->
<!--        <aop:before method="before" pointcut-ref="point"/>-->
<!--        <aop:after method="after" pointcut-ref="point"/>-->
<!--        </aop:aspect>-->
<!--    </aop:config>-->

</beans>

//方式三：使用註解方式實現AOP
@Aspect //標註這個類是一個切面
public class AnnotationPointCut {

    @Before("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("=====方法執行前=====");
    }

    @After("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("=====方法執行後=====");
    }

    //在環繞增強中，我們可以給定一個引數，代表我們要獲取並處理切入的點；
    @Around("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("環繞前");

        System.out.println("signature:"+jp.getSignature());//獲得簽名

        //執行方法
        Object proceed = jp.proceed();//過濾

        System.out.println("環繞後");
        System.out.println(proceed);
    }
}
=========================================================
public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //動態代理代理的是介面:注意點
        UserService userService = context.getBean("userService", UserService.class);

        userService.add();
    }
}

12、整合Mybatis

步驟：

匯入相關jar包

junit
mybatis
mysql資料庫
spring相關的
aop織入
mybatis-spring 【new知識點】

<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.16</version>
    </dependency>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.9</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.3.17</version>
    </dependency>
    <!--Spring運算元據庫的話，還需要一個spring-jdbc-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.3.16</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.9</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>2.0.7</version>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.22</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.9</version>
    </dependency>
</dependencies>

編寫配置檔案
測試

12.1、回憶mybatis

編寫實體類
編寫核心配置檔案
編寫介面
編寫Mapper.xml
測試

12.2、MyBatis-Spring

編寫資料來源配置
sqlSessionFactory
sqlSessionTemplate
需要給介面加實現類
將自己寫的實現類，注入到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>

    <!--設定-->
<!--    <settings>-->
<!--        <setting name="" value=""/>-->
<!--    </settings>-->

</configuration>
<!--============================================================-->
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--DataSource:使用Spring的資料來源替換Mybatis的配置 c3p0 dbcp druid
    我們這裡使用Spring提供的JDBC : org.springframework.jdbc.datasource
    -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&amp;characterEncoding=utf-8&amp;useSSL=true&amp;serverTimezone=GMT"/>
        <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:com/kuang/mapper/*.xml"/>
    </bean>

    <!--SqlSessionTemplate:就是我們使用的sqlSession-->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <!--只能使用構造器注入sqlSessionFactory，因為它沒有set方法-->
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>

</beans>
<!--============================================================-->
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!---->
    <import resource="spring-dao.xml"/>

    <!---->
    <bean id="userMapper" class="com.kuang.mapper.UserMapperImpl">
        <property name="sqlSession" ref="sqlSession"/>
    </bean>

</beans>

public class UserMapperImpl implements UserMapper{

    //我們的所有操作，都使用sqlSession來執行，現在都使用SqlSessionTemplate；
    private SqlSessionTemplate sqlSession;

    public void setSqlSession(SqlSessionTemplate sqlSession) {
        this.sqlSession = sqlSession;
    }

    @Override
    public List<User> selectUser() {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        return mapper.selectUser();
    }
}
==================================================================
public class MyTest {
    @Test
    public void test() throws IOException {

        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
        for (User user : userMapper.selectUser()) {
            System.out.println(user);
        }
    }
}

方式二：

<?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">

    <!--DataSource:使用Spring的資料來源替換Mybatis的配置 c3p0 dbcp druid
    我們這裡使用Spring提供的JDBC : org.springframework.jdbc.datasource
    -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&amp;characterEncoding=utf-8&amp;useSSL=true&amp;serverTimezone=GMT"/>
        <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:com/kuang/mapper/*.xml"/>
    </bean>
</beans>
<!--=======================================================-->
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!---->
    <import resource="spring-dao.xml"/>

    <!---->
    <bean id="userMapper" class="com.kuang.mapper.UserMapperImpl">
        <property name="sqlSession" ref="sqlSession"/>
    </bean>
    <bean id="userMapper2" class="com.kuang.mapper.UserMapperImpl2">
        <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
    </bean>
</beans>
<!--===========================================================-->
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.kuang.mapper.UserMapper">

    <select id="selectUser" resultType="User">
        select * from mybatis.user;
    </select>
</mapper>

@Data
public class User {
    private int id;
    private String name;
    private String pwd;
}
===================================================================
public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper{
    @Override
    public List<User> selectUser() {
        return getSqlSession().getMapper(UserMapper.class).selectUser();
    }
}
===================================================================
public class MyTest {
    @Test
    public void test() throws IOException {

        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        UserMapper userMapper = context.getBean("userMapper2", UserMapper.class);
        for (User user : userMapper.selectUser()) {
            System.out.println(user);
        }
    }
}

13、宣告式事務

1、回顧事務

把一組業務當成一個業務來做；要麼都成功，要麼都失敗！
事務在專案開發中，十分的重要，涉及到資料的一致性問題，不能馬虎！
確保完整性和一致性；

事務ACID原則：

原子性
一致性
隔離性
- 多個業務可能操作同一個資源，防止資料損壞
永續性
- 事務一旦提交，無論系統發生什麼問題，結果都不會再被影響，被持久化的寫到儲存器中！

2、spring中的事務管理

宣告式事務：AOP
程式設計式事務：需要在程式碼中，進行事務的管理

思考：

為什麼需要事務？

如果不配置事務，可能存在資料提交不一致的情況下；
如果我們不在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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       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
                           http://www.springframework.org/schema/tx
                           https://www.springframework.org/schema/tx/spring-tx.xsd">

    <!--DataSource:使用Spring的資料來源替換Mybatis的配置 c3p0 dbcp druid
    我們這裡使用Spring提供的JDBC : org.springframework.jdbc.datasource
    -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&amp;characterEncoding=utf-8&amp;useSSL=true&amp;serverTimezone=GMT"/>
        <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:com/kuang/mapper/*.xml"/>
    </bean>

    <!--配置宣告式事務-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--<constructor-arg ref="dataSource"/>-->
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--結合AOP實現事務的織入-->
    <!--配置事務通知：-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <!--給哪些方法配置事務-->
        <!--配置事務的傳播特性：propagation-->
        <tx:attributes>
            <tx:method name="add" propagation="REQUIRED"/>
            <tx:method name="delete" propagation="REQUIRED"/>
            <tx:method name="update" propagation="REQUIRED"/>
            <tx:method name="select" read-only="true"/>
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

    <!--配置事務切入-->
    <aop:config>
        <aop:pointcut id="txPointCut" expression="execution(* com.kuang.mapper.*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
    </aop:config>

    <bean id="userMapperImpl" class="com.kuang.mapper.UserMapperImpl">
        <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
    </bean>
</beans>
<!--===========================================================-->
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.kuang.mapper.UserMapper">

    <select id="selectUser" resultType="User">
        select * from mybatis.user
    </select>
    <insert id="insertUser" parameterType="User">
        insert into mybatis.user (id,name,pwd) values (#{id},#{name},#{pwd})
    </insert>
    <delete id="deleteUser">
        delete from user where id=#{id}
    </delete>
    <update id="updateUser" parameterType="User">
        update mybatis.user set (name,pwd) values(#{name},#{pwd}) where id=#{id};
    </update>
</mapper>

public interface UserMapper {

    List<User> selectUser();

    int insertUser(User user);

    int deleteUser(int id);

    int updateUser(User user);
}
=========================================================
public class UserMapperImpl extends SqlSessionDaoSupport implements UserMapper {

    public List<User> selectUser() {

        User user = new User(5, "小王", "123312");
        UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
        mapper.insertUser(user);
        mapper.deleteUser(5);

        return mapper.selectUser();
    }

    public int insertUser(User user) {
        return getSqlSession().getMapper(UserMapper.class).insertUser(user);
    }

    public int deleteUser(int id) {
        return getSqlSession().getMapper(UserMapper.class).deleteUser(id);
    }

    public int updateUser(User user) {
        return getSqlSession().getMapper(UserMapper.class).updateUser(user);
    }
}
============================================================
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {

    private int id;
    private String name;
    private String pwd;
}
=============================================================
public class MyTest {

    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-dao.xml");
        UserMapper userMapperImpl = context.getBean("userMapperImpl", UserMapper.class);

        for (User user : userMapperImpl.selectUser()) {
            System.out.println(user);
        }
    }
}

Spring框架詳解
2019-03-27
Spring框架
Spring AOP 詳解
2018-09-02
Spring
Spring Bean 詳解
2022-08-25
SpringBean
Spring Security詳解
2021-04-27
Spring
Spring容器——BeanFactory詳解
2018-07-06
SpringBean
Spring Aop 詳解二
2020-10-21
Spring
Spring Aop 詳解一
2020-10-18
Spring
Spring Boot Security 詳解
2019-05-31
Spring Boot
spring(1)-ApplicationContextAware詳解
2021-10-09
SpringAPPContext
Spring IoC 公共註解詳解
2020-07-08
Spring
【詳解】Spring Security 之 SecurityContext
2019-01-20
SpringContext
【Spring】BeanFactory 解析 bean 詳解
2018-09-17
SpringBean
Spring事件機制詳解
2023-12-14
Spring事件
Spring JdbcTemplate之使用詳解
2019-08-03
SpringJDBC
Java之Spring Boot詳解
2019-05-16
JavaSpring Boot
Spring Boot Admin 2.0 詳解
2019-05-31
Spring Boot
Spring知識點詳解
2022-07-16
Spring
Spring 原始碼詳解(一)
2020-12-18
Spring原始碼
Spring AOP全面詳解(超級詳細)
2022-08-18
Spring
Spring零配置之@Configuration註解詳解
2018-05-04
Spring
spring mvc 框架搭建及詳解
2019-01-14
SpringMVC框架
Spring Boot(四)：Thymeleaf 使用詳解
2019-04-12
Spring Boot
Spring(環境搭建&配置詳解)
2018-08-16
Spring
詳解Spring Retry實現原理
2018-06-07
Spring
Spring入門之IOC詳解
2020-10-15
Spring
Spring EL表示式使用詳解
2024-08-30
Spring
詳解Spring Boot的RedisAutoConfiguration配置
2024-06-14
Spring BootRedis
死磕Spring之AOP篇 - Spring 事務詳解
2021-05-12
Spring
Spring @Conditional註解詳細講解及示例
2020-04-05
Spring
spring boot2整合ES詳解
2018-11-28
Spring Boot
Spring原始碼之九finishRefresh詳解
2022-03-11
Spring原始碼
spring-boot入門程式詳解
2021-09-09
Springboot
Spring @Retryable重試方法呼叫詳解
2020-12-11
Spring
Spring事務管理（詳解+例項）
2020-12-08
Spring
Spring Boot中自動配置Autoconfigure詳解
2024-04-10
Spring Boot
Spring原始碼系列（補充）：詳解ApplicationContext
2023-04-21
Spring原始碼APPContext
Spring Cloud系列（二）：Eureka應用詳解
2020-10-01
SpringCloud
一文詳解Spring Boot的使用
2020-10-01
Spring Boot