leetcode73 - Set Matrix Zeroes - medium

阿新 • • 發佈：2020-10-28

1. Spring

1.1 簡介

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

SSM，SpringMVC + Spring + Mybatis

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

官方下載地址：https://repo.spring.io./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.2.9.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.9.RELEASE</version>
</dependency>

1.2 優點

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

總之一句話，Spring就是一個輕量級控制反轉（IOC），和麵向切面（AOP）的框架！

1.3 組成

1.4 拓展

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

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

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

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

2. IOC理論推導

UserDao介面

public interface UserDao {
    void getUser();
}

UserDaoImpl實現類

public class UserDaoImpl implements UserDao {
    public void getUser() {
        System.out.println("預設獲取使用者的資料");
    }
}
public class UserDaoMysqlImpl implements UserDao {
    public void getUser() {
        System.out.println("mysql獲取使用者資料");
    }
}
public class UserDaoOracleImpl implements UserDao{
    public void getUser() {
        System.out.println("使用者獲取Oracle資料");
    }
}

UserService介面

public interface UserService {
    void getUser();
}

UserServiceImpl實現類

public class UserServiceImpl implements UserService{
    /*
    需要哪個實現類就new哪個實現類。
    假設我們這種需求非常大，每次都需要變動，修改大量程式碼。這種設計的耦合性太高了，牽一髮動全身
    */
    private UserDao userDao = new UserDaoImpl();
    public void getUser() {
        userDao.getUser();
    }
}

測試

public class MyTest {
    public static void main(String[] args) {
        //使用者實際呼叫的是業務層，dao層他們不需要接觸
        UserServiceImpl service = new UserServiceImpl();
        service.getUser();
    }
}

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

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

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

測試：

public class MyTest {
    public static void main(String[] args) {
        //使用者實際呼叫的是業務層，dao層他們不需要接觸
        UserServiceImpl service = new UserServiceImpl();
        service.setUserDao(new UserDaoOracleImpl());//用誰就傳誰
        service.getUser();
    }
}

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

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

IOC本質

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

Ioc是Sprng框架的核心內容，使用多種方式完美的實現了IOC，可以使用XML配置，也可以使用註解，新版本的Spring也可以零配置實現IOC

Spring容器在初始化時先讀取配置檔案，根據配置檔案活元資料建立與組織物件存入容器中，程式使用時再從IOC容器中取出需要的物件

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

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

3. HelloSpring

實體

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

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

    <!--
    使用spring建立物件,在spring中這些都稱為bean
    型別 變數名 = new 型別();
    Hello hello = new Hello();

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

    bean = 物件 new Hello()
    -->
    <bean id="hello" class="com.andy.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中管理了，我們需要使用，直接去裡面取出來就可以！
        getBean：引數即為spring配置檔案中bean的id
         */
        Hello hello = (Hello) context.getBean("hello");
        System.out.println(hello.toString());
    }
}

思考問題：

Hello 物件是誰建立的？

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

hello物件的屬性是由Spring容器設定的！

這個過程就叫控制反轉：

控制：是來控制物件的建立，傳統應用程式的物件是由程式本身控制建立的，使用Spring後，物件是由Spring來建立的

反轉：程式本身不建立物件，而變成被動的接收物件

依賴注入：就是利用Set方式進行注入的

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

可以通過ClassPathXmlApplicationContext瀏覽下底層原始碼

OK，到了現在，我們徹底不用在程式中去改動了，要實現不同的操作，只需要在xml配置檔案中進行修改，所謂的IOC，一句話搞定：物件由Spring來建立，管理，裝配！

4. IOC建立物件的方式

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

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

下標賦值

<!--有參構造第一種，下標賦值-->
<bean id="user" class="com.andy.pojo.User">
    <constructor-arg index="0" value="葉凡"/>
</bean>

型別賦值

<!--有參構造第二種，通過型別建立,不建議使用！-->
<bean id="user" class="com.andy.pojo.User">
    <constructor-arg type="java.lang.String" value="葉凡"/>
</bean>

引數名

<!--有參構造第三種，直接通過引數名來設定-->
<bean id="user" class="com.andy.pojo.User">
    <constructor-arg name="name" value="葉凡"/>
</bean>

總結：在配置檔案載入的時候，容器中管理的物件就已經初始化了！容器中每個物件的例項只有一個！

5. Spring配置

5.1 別名

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

5.2 Bean的配置

<!--
    id：bean 的唯一識別符號，也就相當於我們學的物件名
    class：bean 物件所對應的全限定名：包名+型別
    name：也是別名，而且name更高階，可以同時取多個別名(空格，逗號，分號都可以分割)
-->
<bean id="userT" class="com.andy.pojo.UserT" name="t,u,p">
    <property name="name" value="西部開源"/>
</bean>

5.3 import

這個import，一般用於團隊開發使用，它可以將多個配置檔案，匯入合併為一個

張三
李四
王五

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

applicationContext.xml

<import resource="beans.xml"/>
<import resource="zhagnsan.xml"/>
<import resource="lisi.xml"/>
<import resource="wangwu.xml"/>

使用的時候就用這個總的就可以了

6. 依賴注入

6.1 構造器注入

可檢視 IOC建立物件的方式

6.2 set方式注入【重點】

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

【環境搭建】

複雜型別

public class Address {
    private String address;
}

真實測試物件

public class Student {
    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbies;
    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.andy.pojo.Student">
        <!--1. 普通值注入，value-->
        <property name="name" value="葉凡"/>

    </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.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.andy.pojo.Address">
        <property name="address" value="北京"/>
    </bean>

    <bean id="student" class="com.andy.pojo.Student">
        <!--1. 普通值注入，value -->
        <property name="name" value="葉凡"/>
        <!--2. bean注入，ref -->
        <property name="address" ref="address"/>
        <!--3. 陣列注入，ref -->
        <property name="books">
            <array>
                <value>《紅樓夢》</value>
                <value>《西遊記》</value>
                <value>《水滸傳》</value>
            </array>
        </property>
        <!--4. List -->
        <property name="hobbies">
            <list>
                <value>聽歌</value>
                <value>看電影</value>
                <value>敲程式碼</value>
            </list>
        </property>
        <!--5. Map -->
        <property name="card">
            <map>
                <entry key="身份證" value="110xxxxxxxxxxxx"/>
                <entry key="銀行卡" value="622xxxxxxxxxxxx"/>
            </map>
        </property>
        <!--6. Set -->
        <property name="games">
            <set>
                <value>LOL</value>
                <value>COC</value>
                <value>BOB</value>
            </set>
        </property>
        <!--7. null值 -->
        <property name="wife">
            <null/>
        </property>
        <!--8. Properties
        key = value
        key = value
        key = value
        -->
        <property name="info">
            <props>
                <prop key="driver">001</prop>
                <prop key="url">男性</prop>
                <prop key="username">root</prop>
                <prop key="password">123456</prop>
            </props>
        </property>

    </bean>

</beans>

public static void main(String[] args) {
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    Student student = (Student) context.getBean("student");
    System.out.println(student);
    /*
         Student{
         name='葉凡',
         address=Address{address='北京'},
         books=[《紅樓夢》, 《西遊記》, 《水滸傳》],
         hobbies=[聽歌, 看電影, 敲程式碼],
         card={身份證=110xxxxxxxxxxxx, 銀行卡=622xxxxxxxxxxxx},
         games=[LOL, COC, BOB],
         wife='null',
         info={password=123456, url=男性, driver=001, username=root}}
     */
}

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.andy.pojo.User" p:name="葉凡" p:age="18"/>
    <!--c名稱空間注入，可以通過構造器注入：construct-args-->
    <bean id="userT" class="com.andy.pojo.User" c:age="18" c:name="狂神"/>

</beans>

測試：

@Test
public void test(){
    ApplicationContext context = new ClassPathXmlApplicationContext("userBean.xml");
    User user = context.getBean("userT",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="user" class="com.andy.pojo.User" p:name="葉凡" p:age="18" scope="singleton"/>

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

<bean id="user" class="com.andy.pojo.User" p:name="葉凡" p:age="18" scope="prototype"/>

其餘的 request，session，application，webSocket 這些只能在web開發中使用！

7. Bean的自動裝配

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

在Spring中有三種裝配的方式

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

7.1 測試

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

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

    <bean id="cat" class="com.andy.pojo.Cat"/>
    <bean id="dog" class="com.andy.pojo.Dog"/>
    <bean id="people" class="com.andy.pojo.People">
        <property name="name" value="葉依水"/>
        <property name="cat" ref="cat"/>
        <property name="dog" ref="dog"/>
    </bean>

</beans>

7.2 自動裝配

byName

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

byType

<bean class="com.andy.pojo.Cat"/>
<bean class="com.andy.pojo.Dog"/>
<!--
    byType：會自動在容器上下文中查詢，和自己物件屬性型別相同的bean!
    -->
<bean id="people" class="com.andy.pojo.People" autowire="byType">
    <property name="name" value="葉依水"/>
</bean>

小結：

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

7.3 使用註解實現自動裝配

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）容器中存在，且符合名字 byName

科普：

//@Nullable 欄位標記了此註解，說明這個欄位可以為null
public void setName(@Nullable String name) {
    this.name = name;
}

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

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

public class People {
    //如果顯示定義了Autowired的required屬性為false,說明這個物件可以為Null，否則不允許為空
    @Autowired
    @Qualifier(value = "cateee")
    private Cat cat;
    @Autowired
    @Qualifier(value = "dogbbb")//指定裝配的值bean的id
    private Dog dog;
    private String name;

@Resource註解

public class People {
    @Resource(name = "cat222")
    private Cat cat;
    @Resource
    private Dog dog;
    private String name;

小結：

@Resource與@Autowired 的區別：

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

8. 使用註解開發

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

匯入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>

bean
屬性如何注入

//等價於 <bean id="user" class="com.andy.pojo.User"/>
//@Component 元件
@Component
public class User {
    //相當於 <property name="name" value="石昊"/>
    @Value("石昊")
    public String name;
    @Value("石昊")
    public void setName(String name) {
        this.name = name;
    }
}

衍生的註解

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

@Autowired：自動裝配通過型別，名字
    如果 Autowired 不能唯一自動裝配上屬性，則需要通過@Qualifier(value = "xxx")
@Resource ：自動裝配通過名字，型別
@Component：元件，放在類上，說明這個類被spring管理了，就是bean

作用域

@Scope("singleton")
@Scope("prototype")

小結

xml 與註解

xml更加萬能，適用於任何場景！維護簡單方便！
註解不是自己的類使用不了（別的bean不能引用我的bean），維護相對複雜！

XML與註解的最佳實踐：

xml用來管理bean
註解只負責完成屬性的注入

我們在使用的過程中，只需要注意一個問題：必須讓註解生效，就需要開啟註解的支援！

<!--註解驅動-->
<context:annotation-config/>
<!--指定要掃描的包，這個包下的註解就會生效-->
<context:component-scan base-package="com.andy.pojo"/>

9. 使用Java的方式配置Spring

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

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

實體類

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

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

    public String getName() {
        return name;
    }

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

配置檔案

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

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

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

10. 代理模式

中介，黃牛黨....

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

代理模式的分類：

靜態代理
動態代理

10.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() {
        host.rent();
        seeHouse();
        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 靜態代理加深理解

程式碼步驟

service介面

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void query();
}

service實現

//真實物件
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("查詢了一個使用者");
    }
    /*
    1. 改動原有的業務程式碼，在公司中式大忌
     */
}

service實現的代理

public class UserServiceProxy implements UserService{
    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 userServiceProxy = new UserServiceProxy();
        userServiceProxy.setUserService(userService);
        userServiceProxy.add();
    }
}

聊聊AOP

10.3 動態代理

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

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

程式碼步驟

介面

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

真實物件

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

動態代理

//我們會用這個類自動生成代理類
public class ProxyInvocationHandle 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);
    }
    //處理代理例項，並返回結果
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        seeHouse();
        fare();
        //動態代理的本質，就是使用反射機制實現
        Object result = method.invoke(rent, args);
        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();
        //代理角色：現在沒有
        ProxyInvocationHandle proxyInvocationHandle = new ProxyInvocationHandle();
        //通過呼叫程式處理角色來處理我們要呼叫的介面物件！
        proxyInvocationHandle.setRent(host);
        Rent proxy = (Rent) proxyInvocationHandle.getProxy();//這裡的proxy就是動態生成的，我們並沒有寫
        proxy.rent();
    }
}

再改進

service介面

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void query();
}

service實現

//真實物件
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 ProxyInvocationHandle 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();
        //代理角色，不存在
        ProxyInvocationHandle handle = new ProxyInvocationHandle();
        handle.setTarget(userService);//設定要代理的物件
        //動態生成代理類
        UserService proxy = (UserService) handle.getProxy();
        proxy.delete();
    }
}

動態代理的好處：

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

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

通知型別	連線點	實現介面
前置通知	方法前	org.springframework.aop.MethodBeforeAdvice
後置通知	方法後	org.springframework.aop.AfterReturningAdvice
環繞通知	方法前後	org.aopalliance.intercept.MethodInterceptor
異常丟擲通知	方法丟擲異常	org.springframework.aop.ThrowsAdvice
引介通知	類中增加新的方法屬性	org.springframework.aop.IntroductionInterceptor

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

11.3 使用Spring實現AOP

【重點】使用AOP植入，需要匯入依賴

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

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

//介面
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 Log implements MethodBeforeAdvice {
    /*
    method：要執行的目標物件的方法
    args：引數
    target：目標物件
     */
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"的"+method.getName()+"被執行了");
    }
}
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);
    }
}

<?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"
       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/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">
    
    <!-- 註冊bean -->
    <bean id="userService" class="com.andy.service.UserServiceImpl"/>
    <bean id="log" class="com.andy.log.Log"/>
    <bean id="afterLog" class="com.andy.log.AfterLog"/>
    <!--方式一，使用原生Spring API介面-->
    <!--配置AOP:需要匯入AOP約束-->
    <aop:config>
        <!--切入點:expression:表示式，execution（要執行的位置！* * * * *）-->
        <aop:pointcut id="pointcut" expression="execution(* com.andy.service.UserServiceImpl.*(..))"/>
        <!--執行環繞增強！-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>
</beans>

//測試
public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //注意點：動態代理代理的是介面
        UserService userService = context.getBean("userService", UserService.class);
        userService.delete();
    }
}

方式二：自定義類來實現AOP【主要是切面定義】

//自定義切入
public class DiyPointCut {
    public void before(){
        System.out.println("==========方法執行前==========");
    }
    public void after(){
        System.out.println("==========方法執行後==========");
    }
}

<?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"
       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/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">
    
    <!--方式二，自定義類-->
    <bean id="diy" class="com.andy.diy.DiyPointCut"/>
    <aop:config>
        <!--自定義切面，ref要引用的類-->
        <aop:aspect ref="diy">
            <!--切入點-->
            <aop:pointcut id="point" expression="execution(* com.andy.service.UserServiceImpl.*(..))"/>
            <!--通知-->
            <aop:before method="before" pointcut-ref="point"/>
            <aop:after method="after" pointcut-ref="point"/>
        </aop:aspect>
    </aop:config>
</beans>

方式三：使用註解實現！

@Aspect
public class AnnotationPointcut {
    @Before("execution(* com.andy.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("==========方法執行前==========");
    }
    @After("execution(* com.andy.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("==========方法執行後==========");
    }
    //在環繞增強中，我們可以給定義一個參宿和，代表我們要獲取處理切入點
    @Around("execution(* com.andy.service.UserServiceImpl.*(..))")
    public void round(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("環繞前");
        Object proceed = jp.proceed();
        System.out.println("環繞後");
        System.out.println(jp.getSignature());//獲得簽名
    }
}

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

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

12. 整合Mybatis

步驟：

匯入相關Jar
- junit
- mybatis
- mysql資料庫
- spring相關的
- aop植入
- mybatis-spring【new】

<dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.49</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.6</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.9.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.6</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.9.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.5</version>
        </dependency>
    </dependencies>

編寫配置檔案
測試

12.1 回憶Mybatis

編寫實體類

import lombok.Data;
@Data
public class User {
    private int id;
    private String name;
    private String pwd;
}

編寫核心配置檔案

<?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.andy.pojo"/>
    </typeAliases>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
    <!-- 每一個Mapper.xml都需要在Mybatis核心配置檔案中配置 -->
    <mappers>
        <mapper class="com.andy.mapper.UserMapper"/>
    </mappers>
</configuration>

編寫介面

public interface UserMapper {
    public List<User> selectUser();
}

編寫Mapper.xml

<?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.andy.mapper.UserMapper">
    <select id="selectUser" resultType="user">
        select * from mybatis.user
    </select>
</mapper>

測試

@Test
    public void testMybatis() throws IOException {
        String resources = "mybatis-config.xml";
        InputStream in = Resources.getResourceAsStream(resources);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> userList = mapper.selectUser();
        for (User user : userList) {
            System.out.println(user);
        }
    }

12.2 Mybatis-Spring【一】

編寫資料來源配置

<!--DataSource：使用Spring的資料來源替換Mybatis配置 c3p0,dbcp,druid
    我們這裡用spring提供的JDBC
    -->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
    <property name="username" value="root"/>
    <property name="password" value="root"/>
</bean>

SqlSessionFactory

<!--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/andy/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;
    }
    @Override
    public List<User> selectUser() {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        return mapper.selectUser();
    }
}

將自己些的實現類注入倒Spring中

<bean id="userMapper" class="com.andy.mapper.UserMapperImpl">
        <property name="sqlSession" ref="sqlSession"/>
    </bea\n>

測試

@Test
    public void testMybatis() throws IOException {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
        for (User user : userMapper.selectUser()) {
            System.out.println(user);
        }
    }

12.3 Mybatis-Spring【二】

修改實現類

public class UserMapperImplT extends SqlSessionDaoSupport implements UserMapper{
    @Override
    public List<User> selectUser() {
        return getSqlSession().getMapper(UserMapper.class).selectUser();
    }
}

註冊實現類

<bean id="userMapperT" class="com.andy.mapper.UserMapperImplT">
    <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
</bean>

測試

@Test
public void testMybatis() throws IOException {
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    UserMapper userMapper = context.getBean("userMapperT", UserMapper.class);
    for (User user : userMapper.selectUser()) {
        System.out.println(user);
    }
}

13. 宣告式事務

13.1 回顧事務

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

事務的ACID原則：

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

程式碼案例：

mapper介面

public interface UserMapper {
    public List<User> selectUser();
    //新增一個使用者
    public int addUser(User user);
    //刪除一個使用者
    public int deleteUser(@Param("id") int id);
}

mapper.xml（delete語句有問題）

<?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.andy.mapper.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 mybatis.user where id = #{id}
    </delete>
</mapper>

mapper實現

public class UserMapperImpl extends SqlSessionDaoSupport implements UserMapper{
    @Override
    public List<User> selectUser() {
        User user = new User(8, "黑皇", "654321");
        UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
        int i = mapper.addUser(user);
        System.out.println(i);
        int j = mapper.deleteUser(8);
        System.out.println(j);
        return mapper.selectUser();
    }
    @Override
    public int addUser(User user) {
        return getSqlSession().getMapper(UserMapper.class).addUser(user);
    }
    @Override
    public int deleteUser(int id) {
        return getSqlSession().getMapper(UserMapper.class).deleteUser(id);
    }
}

測試結果，異常
- selectUser() 方法中有插入有刪除，他們是同一個業務，需要滿足事務。
- 結果插入執行了，刪除與查詢均未執行

13.2 spring中事務管理

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

宣告式事務實現方式（改進以上程式碼）

<!--結合AOP實現事務的植入-->
<!--配置事務通知-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <!--給哪些方法配置事務-->
    <!--配置事務的傳播特性：new propagation -->
    <tx:attributes>
        <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:method name="*" propagation="REQUIRED"/><!--一般用此一個即可-->
    </tx:attributes>
</tx:advice>
<!--配置事務的切入AOP-->
<aop:config>
    <aop:pointcut id="txPointCut" expression="execution(* com.andy.mapper.*.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
</aop:config>

思考：

為什麼需要事務？

如果不配置事務，可能存在資料提交不一致的情況
如果我們不在Spring中去配置宣告式事務，我們就需要在程式碼中手動配置事務！
事務在專案開發中十分重要，涉及到資料的一致性和完整性，不可馬虎！