Spring框架介紹

本文轉載自查看原文 2021-08-16 10:05 102 知識總結

Spring框架介紹

1.Spring

1.1 簡介

2002年，首次推出了Spring框架的雛形：interface21框架！
Spring框架即以interface21框架為基礎，經過重新的設計，並不斷豐富其內涵，於2004年3月24日，發布了1.0正式版。
Rod Jahnson，Spring Framework創始人，著名作者，悉尼大學的博士，專業是音樂學。
spring理念：使現有的技術更加容易使用，本身是一個大雜燴，整合了現有的技術框架！
SSH：Struct2 + Spring + Hibernate
SSM：SpringMVC + Spring + Mybatis

官網：https://spring.io/projects/spring-framework#overview

1.2 優點：

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

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

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

1.3 組成

1.4 拓展

現代化的Java開發，說白了就是基於Spring的開發！

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

2.IOC理論推導

UserDao接口
UserDaoImpl實現類

public interface UserDao {
   public void getUser();
}
public class UserDaoImpl implements UserDao {

    public void getUser() {
        System.out.println("默認獲取用戶的數據");
    }
}
public class UserDaoOracleImpl implements UserDao {
    public void getUser() {
        System.out.println("Oracle獲取用於數據！");
    }
}

UserService業務接口
UserServiceImpl業務實現類

public interface UserService {
    public void getUser();
}

使用Set注入之前

使用Set注入之后

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

我們使用一個Set接口實現，已經發生了革命性的變化！

// 利用set進行實現動態值的注入！
public void setUserDao(UserDao userDao) {
    this.userDao = userDao;
}

之前，程序是主動創建對象！控制權在程序員手上！
使用Set注入后，程序不再具有主動性，而是變成了被動的接受對象！

這種思想，從本質上解決了問題，我們程序員不用再去管理對象的創建了。系統的耦合性大大降低，可以更加專注在業務的實現上！這是IOC的原型！

3.IOC本質

控制反轉IOC（Inversion of Control），是一種設計思想，DI（依賴注入）是實現IOC的一種方法，也有人認為Dl只是IOC的另一種說法。沒有IOC的程序中，我們使用面向對象編程，對象的創建與對象間的依賴關系完全硬編碼在程序中，對象的創建由程序自己控制，控制反轉后將對象的創建轉移給第三方，個人認為所謂控制反轉就是：獲得依賴對象的方式反轉了。

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

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

4.HelloSpring

4.1 導入Spring相關jar包

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

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.8</version>
</dependency>

4.2 編寫相關代碼

編寫一個Hello實體類

public class Hello {

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

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

編寫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創建和管理-->
    <bean id="hello" class="com.mc.pojo.Hello">
        <property name="name" value="Spring"/>
    </bean>

</beans>

進行測試

public class MyTest {
    public static void main(String[] args) {
        // 獲取Spring的上下文對象
        // 解析beans.xml文件，生成管理相應的Bean對象
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        // 我們的對象現在都在Spring中管理了，我們要使用，直接去里面取出來就可以！
        // getBean：參數即為spring配置文件中bean的id
        Hello hello = (Hello) context.getBean("hello");
        System.out.println(hello.toString());
    }
}

4.3 小結

該例子設計到了Spring的三個核心：

所有的類都需要裝配到bean里面
所有的bean都需要通過容器去取
容器中取得的bean就是一個對象

現在只需要改動bean標簽即可創建不同對象

<bean id="mysqlImpl" class="com.mc.pojo.UserDaoMysqlImpl"/>
<bean id="oracleImpl" class="com.mc.pojo.UserDaoOracleImpl"/>

<bean id="UserServiceImpl" class="com.mc.service.UserServiceImpl">
    <!--
         ref： 引用Spring容器中創建好的對象
         value： 具體的值，基本數據類型
    -->
    <property name="userDao" ref="mysqlImpl"/>
</bean>

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

思考：

Hello對象是誰創建的?
- Hello 對象是由Spring創建的
Hello 對象的屬性是怎么設置的?
- Hello 對象的屬性是由Spring容器設置的

這個過程就叫控制反轉︰

控制:誰來控制對象的創建，傳統應用程序的對象是由程序本身控制創建的，使用Spring后，對象是由Spring來創建的
反轉∶程序本身不創建對象，而變成被動的接收對象
依賴注入:就是利用set方法來進行注入的
IOC是一種編程思想，由主動的編程變成被動的接收
可以通過newClassPathXmlApplicationContext去瀏覽一下底層源碼
OK，到了現在，我們徹底不用再程序中去改動了，要實現不同的操作，只需要在xml配置文件中進行修改，所謂的lOC,一句話搞定:對象由Spring來創建，管理，裝配！

5.IOC創建對象的方式

5.1 默認使用無參構造創建對象

<bean id="user" class="com.mc.pojo.User">
    <property name="name" value="MC"/>
</bean>

5.2 假設我們要使用有參構造來創建對象

方法一：下標賦值

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

方法二：通過類型創建對象，不建議使用

<bean id="user" class="com.mc.pojo.User">
    <constructor-arg type="java.lang.String" value="qinjiang"/>
</bean>

方法三：直接通過參數名創建對象

<bean id="user" class="com.mc.pojo.User">
    <constructor-arg name="name" value="狂神"/>
</bean>

總結：在配置文件加載的時候，容器中管理的對象（bean）就已經初始化了！

6.Spring配置

6.1 別名

<!--別名，如果添加了別名，我們也可以使用別名獲取到這個對象-->
<alias name="user" alias="userNew"/>

6.2 Bean的配置

<!--
    id： bean的唯一標識符，也就是相當於我們學的對象名
    class： bean對象所對應的全限定名：  包名 + 類型
    name： 也是別名，而且name可以同時取多個別名
-->
<bean id="userT" class="com.mc.pojo.UserT" name="userT2 u2,u3;u4">
    <property name="name" value="西部開源"/>
</bean>

6.3 import

這個import，一般用於團隊開發使用，他可以將多個配置文件，導入合並為一個

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

張三
李四
王五
applicationContext.xml

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

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

7.依賴注入

7.1 構造器注入

之前分析過，見5.1~5.2

7.2 Set方式注入【重點】

依賴注入：Set注入！
- 依賴：bean對象的創建依賴於容器！
- 注入：bean對象中的所有屬性，由容器來注入！

【環境搭建】

1.復雜類型

public class Address {
    private String address;

    public String getAddress() {
        return address;
    }

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

2.真實測試對象

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

3.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.mc.pojo.Student">
        <!--第一種，普通值注入，直接使用value-->
        <property name="name" value="秦疆"/>
    </bean>

</beans>

4.測試類

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

完善注入信息

<?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.mc.pojo.Address">
        <property name="address" value="西安"/>
    </bean>
    <bean id="student" class="com.mc.pojo.Student">
        <!--第一種，普通值注入直接使用value-->
        <property name="name" value="秦疆"/>
        <!--第二種，bean注入，使用ref-->
        <property name="address" ref="address"/>
        <!--第三種，數組注入，使用array-->
        <property name="books">
            <array>
                <value>紅樓夢</value>
                <value>水滸傳</value>
                <value>三國演義</value>
                <value>西游記</value>
            </array>
        </property>
        <!--第四種，List注入，使用list-->
        <property name="hobbys">
            <list>
                <value>聽歌</value>
                <value>敲代碼</value>
                <value>看電影</value>
            </list>
        </property>
        <!--第五種，Map注入，使用map-->
        <property name="card">
            <map>
                <entry key="身份證" value="231231231231231"/>
                <entry key="銀行卡" value="156436465231311"/>
            </map>
        </property>
        <!--第六種，Set注入，使用set-->
        <property name="games">
            <set>
                <value>LOL</value>
                <value>COC</value>
                <value>BOB</value>
            </set>
        </property>
        <!--第七種，null注入，使用null-->
        <property name="wife">
            <null/>
        </property>
        <!--第八種，Properties注入，使用props-->
        <property name="info">
            <props>
                <prop key="學號">20210812</prop>
                <prop key="姓名">小李</prop>
                <prop key="性別">男</prop>
            </props>
        </property>
    </bean>

</beans>

7.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.mc.pojo.User" p:name="狂神" p:age="18"/>

    <!--c命名空間注入，通過構造器注入：construct-args-->
    <bean id="user2" class="com.mc.pojo.User" c:name="秦疆" c:age="20"/>
</beans>

測試：

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

7.4 bean的作用域

單例模式（Spring默認機制）

<bean id="user" class="com.mc.pojo.User" p:name="狂神" p:age="18" scope="singleton"/>

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

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

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

8.Bean的自動裝配

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

在Spring中有三種自動裝配的方式

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

8.1 測試

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

8.2 ByName自動裝配

<!--
    byName： 會自動在容器上下文中查找和自己對象set方法后面的值對應的beanid
-->
<bean id="people" class="com.mc.pojo.People" autowire="byName">
    <property name="name" value="小狂神"/>
</bean>

8.3 ByType自動裝配

<!--
    byName： 會自動在容器上下文中查找和自己對象set方法后面的值對應的beanid
    byType： 會自動在容器上下文中查找和自己對象屬性類型相同的bean
-->
<bean id="people" class="com.mc.pojo.People" autowire="byType">
    <property name="name" value="小狂神"/>
</bean>

小結：

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

8.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方法了，前提是你這個自動裝配的屬性在lOC (Spring)容器中存在，且符合名字byname!

科普：

@Nullable  字段標記了這個注解，說明這個字段可以為null

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

測試代碼

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

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

public class People {
    @Autowired
    @Qualifier(value = "dog11")
    private Dog dog;
    
    @Autowired
    @Qualifier(value = "cat11")
    private Cat cat;
    private String name;
}

@Resource注解

public class People {
    @Resource
    private Dog dog;

    @Resource(name = "cat2")
    private Cat cat;
}

小結：

@Resource 和@ Autowired 的區別:

都是用來自動裝配的，都可以放在屬性字段上
@Autowired 通過byType的方式實現，而且必須要求這個對象存在! 【常用】
@Resource 默認通過byName的方式實現，如果找不到名字，則通過byType實現！如果兩個都找不到的情況下，就報錯!【常用】
執行順序不同：@Autowired通過byType的方式實現。@Resource默認通過byName的方式實現。

9.使用注解開發

在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

屬性如何注入

放在類上，說明這個類被Spring管理了，就是注冊bean

// 等價於<bean id="user" class="com.mc.pojo.User"/>
// @Component： 組件
@Component
public class User {

    public String name;

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

衍生的注解

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

自動裝配置

@Autowired：自動裝配通過類型。名字
  如果Autowired不能唯一自動裝配上屬性，則需要通過@Qualifier(value="xxx")
@Nullable字段標記了這個注解，說明這個字段可以為null
@Resource:自動裝配通過名字、類型

作用域

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

    public String name;

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

小結

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

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

10.使用Java的方式配置Spring

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

JavaConfig 是Spring的一個子項目，在Spring 4 之后，它成為了一個核心功能！

實體類

// 這里這個注解的意思，就是說這個類被Spring接管了，注冊到了容器中
@Component
public class User {

    public String name;

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

    public String getName() {
        return name;
    }

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

配置文件

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

    // 注冊一個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(MyConfig.class);
        User getUser = (User) context.getBean("user");
        System.out.println(getUser.getName());
    }
}

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

11.代理模式

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

代理模式的分類：

靜態代理
動態代理

11.1 靜態代理

角色分析：

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

實現步驟：

接口

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

真實角色

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

代理角色

public class Proxy implements Rent{
    private Host host;

    public Proxy() {
    }

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

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

代理模式的好處：

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

缺點：

一個真實角色就會產生一個代理角色，代碼量會翻倍，開發效率會變低

11.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("查詢了一個用戶！");
    }
}

代理角色

public class UserServiceProxy 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();

        UserServiceProxy proxy = new UserServiceProxy();
        proxy.setUserService(userService);
        proxy.add();
    }
}

聊聊AOP

11.3 動態代理

動態代理和靜態代理角色一樣
動態代理的代理類是動態生成的，不是我們直接寫好的
動態代理分為兩大類：基於接口的動態代理，基於類的動態代理
- 基於接口：JDK動態代理【我們在這里使用】
- 基於類：cglib
- Java字節碼實現：Javasist

需要了解兩個類：Proxy：代理，InvocationHandler：調用處理程序

動態代理的好處：

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

代碼實現：

動態生成代理類

// 我們會用這個類自動生成代理類
public class ProxylnvocationHandler implements InvocationHandler {

    // 被代理的接口
    private Object target;

    public void setTarget(Object target) {
        this.target = target;
    }

    // 生成得到代理類
    public Object getProxy(){
        return  Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }

    // 處理代理實例，並返回結果
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log(method.getName());
        // 動態代理的本質，就是使用反射機制實現！
        Object result = method.invoke(target, args);

        return result;
    }

    public void log(String msg){
        System.out.println("執行了"+msg+"方法！");
    }
}

客戶端訪問代理角色

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

12.AOP

12.1 什么是AOP

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

12.2 AOP在Spring中的作用

提供聲明式事務，允許用戶自定義切面

橫切關注點：跨越應用程序多個模塊的方法或功能。即是與我們業務邏輯無關的，但是我們需要關注的部分，就是橫切關注點。如日志，安全，緩存，事務等等....
切面（ASPECT）：橫切關注點被模塊化的特殊對象。即它是一個類。
通知（Advice）：切面必須要完成的工作。即它是類中的一個方法。
目標（Target）︰被通知對象。
代理（Proxy）︰向目標對象應用通知之后創建的對象。
切入點（PointCut）：切面通知執行的“地點“的定義。
連接點（JointPoint）：與切入點匹配的執行點。

SpringAOP中，通過Advice定義橫切邏輯，Spring中支持5種類型的Advice：

即AOP在不改變原有代碼的情況下，去增加新的功能

12.3 使用Spring實現AOP

【重點】使用AOP之前，需要導入一個依賴包

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

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

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

    <!--方式一： 使用原生的Spring API接口-->
    <!--配置aop： 需要導入aop的約束-->
    <!--<aop:config>
        &lt;!&ndash;切入點： expression表達式，execution(要執行的位置)&ndash;&gt;
        <aop:pointcut id="pointcut" expression="execution(* com.mc.service.UserServiceImpl.*(..))"/>

        &lt;!&ndash;執行環繞增加&ndash;&gt;
        <aop:advisor advice-ref="beforeLog" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>

    </aop:config>-->

    <!--方式二： 自定義類-->
   <!-- <bean id="diy" class="com.mc.diy.DiyPointCut"/>
    <aop:config>
        &lt;!&ndash;自定義切面，ref 要引用的類&ndash;&gt;
        <aop:aspect ref="diy">
            &lt;!&ndash;切入點&ndash;&gt;
            <aop:pointcut id="point" expression="execution(* com.mc.service.UserServiceImpl.*(..))"/>
            &lt;!&ndash;通知&ndash;&gt;
            <aop:before method="before" pointcut-ref="point"/>
            <aop:after method="after" pointcut-ref="point"/>
        </aop:aspect>

    </aop:config>-->

    <!--方式三： 使用注解-->
    <bean id="annotationPointCut" class="com.mc.diy.AnnotationPointCut"/>
    <!--開啟注解支持   JDK(默認  proxy-target-class="false")  cglib(proxy-target-class="true")-->
    <aop:aspectj-autoproxy proxy-target-class="false"/>

</beans>

13.整合Mybatis

步驟：

導入相關jar包
- junit
- mybatis
- mysql數據庫
- spring相關的
- aop織入
- mybatis-spring 【new】

<dependencies>
    <!--  junit驅動 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>

    <!--  mysql驅動 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.21</version>
    </dependency>

    <!--  mybatis驅動 -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.2</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.3.5</version>
    </dependency>

    <!--Spring操作數據庫的話，還需要一個spring-jdbc包 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.3.5</version>
    </dependency>

    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.7</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>2.0.6</version>
    </dependency>
    
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.20</version>
        <scope>provided</scope>
    </dependency>

</dependencies>

編寫配置文件
測試

13.1 回憶Mybatis

編寫實體類
編寫核心配置文件
編寫接口
編寫Mapper.xml
測試

13.2 Mybatis-Spring

編寫數據源配置

<!--DataSource： 使用Spring的數據源替換Mybatis的配置
        我們這里使用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?useSSL=false&amp;serverTimezone=GMT%2B8&amp;useUnicode=true&amp;characterEncoding=UTF-8&amp;allowPublicKeyRetrieval=true"/>
    <property name="username" value="root"/>
    <property name="password" value="mc123456"/>
</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/mc/mapper/*.xml"/>
</bean>

sqlSessionTemplate

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

需要給接口加實現類

public class UserMapperImpl implements UserMapper {

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

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

    public List<User> selectUser() {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        return mapper.selectUser();
    }
}

將自己寫的實現類，注入到Spring中

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

測試使用即可!

14.聲明式事務

14.1 事務

把一組業務當成一個業務來做，要么都成功，要么都失敗！
事務在項目開發中，十分的重要，涉及到數據的一致性問題，不能馬虎！
確保完整性和一致性

事務ACID原則：

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

14.2 Spring中的事務管理

聲明式事務：AOP

<!--配置聲明式事務-->
<bean id="transactionManage" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>
<!--結合AOP實現事務的織入-->
<!--配置事務通知-->
<tx:advice id="txAdvice" transaction-manager="transactionManage">
    <!--給哪些方法配置事務-->
    <!--配置事務的傳播特性： propagation-->
    <tx:attributes>
        <tx:method name="*" propagation="REQUIRED"/>
        <tx:method name="add" propagation="REQUIRED"/>
        <tx:method name="delete" propagation="REQUIRED"/>
        <tx:method name="update" propagation="REQUIRED"/>
        <tx:method name="query" read-only="true"/>
    </tx:attributes>
</tx:advice>

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

編程式事務：需要在代碼中進行事務的管理

思考：為什么需要事務？

如果不配置事務，可能存在數據提交不一致的情況
如果我們不在Spring中去配置聲明式事務，我們就需要在代碼中手動配置事務
事務在項目的開發中十分重要，涉及到數據的一致性和完整性問題，不容馬虎！

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 Spring框架介紹 1、spring框架介紹關於如何介紹spring框架。 Spring詳解（一）----Spring框架介紹 Spring Resource框架體系介紹 spring框架介紹以及簡單使用 Spring框架各模塊功能介紹 Spring框架IOC和AOP介紹 CXF框架介紹及Spring集成 IOC和DI的概念，以及Spring框架的介紹