狂神Spring入门笔记

1、Spring

1.1.简介

• Spring:春天---->给软件带来了春天

• 2002年，Rod Jahnson首次推出了Spring框架雏形interface21框架。

• 2004年3月24日，Spring框架以interface21框架为基础，经过重新设计，发布了1.0正式版。

很难想象Rod Johnson的学历 , 他是悉尼大学的博士，然而他的专业不是计算机，而是音乐学。

Spring理念 : 使现有技术更加实用 . 本身就是一个大杂烩 , 整合现有的框架技术

官网 : http://spring.io/

官方下载地址 : https://repo.spring.io/libs-release-local/org/springframework/spring/

参考文档:https://docs.spring.io/spring-framework/docs/5.2.0.RELEASE/spring-framework-reference/index.html

Spring Framework Documentation

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

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->

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

            <dependency>

                <groupId>org.springframework</groupId>
                      <artifactId>spring-jdbc</artifactId>
                <version>5.3.9</version>
            </dependency>

1.2 优点

• Spring是一个开源的免费的框架(容器)
• Spring是一个轻量级的,非入侵式的框架
• 控制反转(IOC) ,面向切面编程(AoP)
• 支持事务的处理,对框架整合的支持

总结一句话:Spring就是一个轻量级的控制反转(IoC)和面向切面编程的(AOP)的框架

1.3组成

Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式 .

组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下：

核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转（IOC） 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。
Spring 上下文：Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。
Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向切面的编程功能 , 集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理任何支持 AOP的对象。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖组件，就可以将声明性事务管理集成到应用程序中。
Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。
Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。
Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。
Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。

1.4扩展

• Spring Boot

1. 一个快速开发的脚手架
2. 基于SpringBoot可以快速的开发单个微服务
3. 约定大于配置!

Spring Cloud

SpringCloud 是基于SpringBoot实现的

因为现在大多数公司都在用SpringBoot开发，学习SpringBoot之前要学习SPring与SpringMvc

弊端:发展太久之后，违背了原来理念!配置十分繁琐,人称:“配置地狱”

2、IOC理论推论

1.1IoC基础

创建Maven

1、先写一个UserDao接口

 void getUser();

2、再去写UserDaoImpl的实现类

public class UserDaoImpl implements UserDao {

    public void getUser() {
        System.out.println("hello lsa");
    }
}

3、然后去写UserService的接口

  void getUser();

4、最后去写UserServiceImpl的实现类

    // UserDao userDao = new UserDaoImpl();

    public void getUser() {
        userDao.getUser();
    }

5、测试

public class Mytest {
    public static void main(String[] args) {
        UserService userService = new UserServiceImpl();
        userService.getUser();
    }
}

这是我们原来的写法

现在把UserDao的实现类增加一个

   public void getUser() {
        System.out.println("HELLO MYSQL");
    }

我们要使用Mysql的话,我们就需要去service里去修改

   // UserDao userDao = new UserDaoImpl();
    UserDao userDao = new UserDaoMysqlImpl();

    public void getUser() {
        
        userDao.getUser();
    }

在假设, 我们再增加一个Userdao的实现类 .

public class UserDaooracleImpl implements UserDao {
    public void getUser() {
        System.out.println("HELLO oracle");
    }

}

那么我们要使用Oracle , 又需要去service实现类里面修改对应的实现 . 假设我们的这种需求非常大 , 这种方式就根本不适用了, 甚至反人类对吧 , 每次变动 , 都需要修改大量代码 . 这种设计的耦合性太高了, 牵一发而动全身 .

那我们如何去解决呢 ?

我们可以在需要用到他的地方 , 不去实现它 , 而是留出一个接口 , 利用set , 我们去代码里修改下 .

public class UserServiceImpl implements UserService {
   private UserDao userDao;
// 利用set实现
   public void setUserDao(UserDao userDao) {
       this.userDao = userDao;
  }

   @Override
   public void getUser() {
       userDao.getUser();
  }
}

现在去我们的测试类里 , 进行测试 ;

@Test
public void test(){
   UserServiceImpl service = new UserServiceImpl();
   service.setUserDao( new UserDaoMySqlImpl() );
   service.getUser();
   //那我们现在又想用Oracle去实现呢
   service.setUserDao( new UserDaoOracleImpl() );
   service.getUser();
}

在我们之前的业务中，用户的需求可能会影响我们原来的代码,我们需要根据用户的需求去修改代码

代码量十分大,修改成本高,

以前所有东西都是由程序员去进行控制创建，而现在是由我们自行控制创建对象 , 把主动权交给了调用者 . 程序不用去管怎么创建,怎么实现了 . 它只负责提供一个接口

这种思想 , 从本质上解决了问题 , 我们程序员不再去管理对象的创建了 , 更多的去关注业务的实现 . 耦合性大大降低 . 这也就是IOC的原型 !

总结:刚开始主动权在业务层，最后升级到用户这就是IoC的原型

1.2、IOC本质

==控制反转IoC(Inversion of Control)，是一种设计思想，DI(依赖注入)是实现IoC的一种方法，也有人认为DI只是IoC的另一种说法 。==没有IoC的程序中 , 我们使用面向对象编程 , 对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是：获得依赖对象的方式反转了。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3dr1RtHh-1671344946866)(C:\Users\卢申澳\AppData\Local\Temp\1670833304454.png)]

IoC是Spring框架的核心内容，使用多种方式完美的实现了IoC，可以使用XML配置，也可以使用注解，新版本的Spring也可以零配置实现IoC。

Spring容器在初始化时先读取配置文件，根据配置文件或元数据创建与组织对象存入容器中，程序使用时再从Ioc容器中取出需要的对象。

采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。

控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection,DI）。

3、HelloSpring

3.1在pom.xml里导入依赖

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

3.2编写一个实体类

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 + '\'' +
                '}';
    }
}

3.3在resources中创建一个ApplicationContextbeans.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 http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--
     使用Spring来创建对象，在Spring这些都称为Bean
     类型 变量名 = new 类型();
     Hello hello = new Hello()
      id = 变量名
      class = new 类型()
      property 相当于给他赋值一个对象
      ref:引用Spring容器中创建好的对象
      value:具体的值，基本数据类型
   
   -->
    
    <bean id="hello" class="com.lsa.pojo.Hello">
        <property name="str" value="Spring"/>
    </bean>
</beans>

3.4测试

   public static void main(String[] args) {

        //获取Spring的上下文对象 ;拿到Spring的容器
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //我们的对象现在都在Spring中的管理了,我们要使用,直接去里面取出来就可以了
        //容器在手,天下我有,需要什么,就直接get什么！！
        Hello hello = (Hello) context.getBean("hello");
        System.out.println(hello);
    }

3.5思考

• Hello 对象是谁创建的 ? hello 对象是由Spring创建的

• Hello 对象的属性是怎么设置的 ? hello 对象的属性是由Spring容器设置的

  这个过程就叫控制反转:

  控制:谁来控制对象的创建,传统应用程序的对象是由程序本身控制创建的,使用Spring后,对象是由Spring来创建的

  反转:程序本身不创建对象,而变成被动的接收对象

  依赖注入:即使利用set方法来进行注入的

  IOC是一种编程思想,由主动的编程变成被动的接收

  可以通过newClassPathXmlApplicationContext去浏览一下底层源码

  OK , 到了现在 , 我们彻底不用再程序中去改动了 , 要实现不同的操作 , 只需要在xml配置文件中进行修改 , 所谓的IoC,一句话搞定 : 对象由Spring 来创建 , 管理 , 装配 !

4、IOC创建对象的方式构造对象

1.使用无参构造对象

默认的就是

2.使用有参构造对象

• 1.下标赋值

  <!--第一种:下标赋值！！-->
     <bean id="user" class="com.lsa.pojo.User">
         <constructor-arg index="0" value="卢申澳"/>
     </bean>
  

• 2.通过类型创建

 <!--第二种:通过类型创建，不建议使用-->
    <bean id="user" class="com.lsa.pojo.User">
        <constructor-arg type="java.lang.String" value="卢申澳"/>
    </bean>

• 3.通过参数名创建

 <!--    第三种:直接通过参数名来使用-->
<bean id="user" class="com.lsa.pojo.User">
        <constructor-arg name="username" value="卢申澳"/>
    </bean>

5、Spring配置

5.1、别名

<!-- 如果使用了别名我们可以用别名定义-->
    <alias name="user" alias="user4"/>

5.2、Bean的配置

  <!--
     id: 是bean的标识符,要唯一,如果没有配置id,name就是默认标识符
         如果配置id,又配置了name,那么name是别名
         name可以设置多个别名,可以用逗号,分号,空格隔开
  calss :bean 对象所对应的全限类名  :包名+类名  new 类型()
   如果不配置id和name,可以根据applicationContext.getBean(.class)获取对象;

class是bean的全限定名=包名+类名
    -->3
    <bean id="userT" class="com.lsa.pojo.UserT" name="user2 u2,u3;u4">
        <property name="username" value="卢申澳2"/>
    </bean>

5.3、impot

团队的合作通过import来实现 .

一般用于团队开发使用,他可以将对各配置文件，合并成一个

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bNsBSA73-1671344946868)(C:\Users\卢申澳\AppData\Local\Temp\1670836290255.png)]

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

6、依赖注入

6.1、构造器注入

我们在之前的案例已经讲过了

    private String name;
    private String age;

    public User() {
    }

    public User(String name, String age) {
        this.name = name;
        this.age = age;
    }

分为有参和无参

无参就是默认的

有参有三种

<constructor-arg index="0" value="卢申澳"/>
<constructor-arg type="java.lang.String" value="卢申澳"/>
<constructor-arg name="username" value="卢申澳"/>

6.2、Set 方式注入 （重点）

• 依赖注入:set注入!

• 依赖:bean对象的创建依赖于容器

• 注入:bean对象中的 所有属性，由容器来注入

  要求被注入的属性 , 必须有set方法 , set方法的方法名由set + 属性首字母大写 , 如果属性是boolean类型 , 没有set方法 , 是 is .

搭建环境

• 1.pojo

  1.Student

package com.lsa.pojo;

import com.sun.xml.internal.fastinfoset.sax.Properties;

import java.util.List;
import java.util.Map;
import java.util.Set;

public class Student {
    private String name;
    private Adders adders;
    private String[] books;
    private List<String> hobbys;
    private Map<String, String> card;
    private Set<String> games;
    private String wife;
    private Properties info;

    public String getName() {
        return name;
    }

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

    public Adders getAdders() {
        return adders;
    }

    public void setAdders(Adders adders) {
        this.adders = adders;
    }

    public String[] getBooks() {
        return books;
    }

    public void setBooks(String[] books) {
        this.books = books;
    }

    public List<String> getHobbys() {
        return hobbys;
    }

    public void setHobbys(List<String> hobbys) {
        this.hobbys = hobbys;
    }

    public Map<String, String> getCard() {
        return card;
    }

    public void setCard(Map<String, String> card) {
        this.card = card;
    }

    public Set<String> getGames() {
        return games;
    }

    public void setGames(Set<String> games) {
        this.games = games;
    }

    public String getWife() {
        return wife;
    }

    public void setWife(String wife) {
        this.wife = wife;
    }

    public Properties getInfo() {
        return info;
    }

    public void setInfo(Properties info) {
        this.info = info;
    }    
}

2.adders

package com.lsa.pojo;

public class Adders {
    private String addres;

    public String getAddres() {
        return addres;
    }

    public void setAddres(String addres) {
        this.addres = addres;
    }

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

• 2.beanx.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 http://www.springframework.org/schema/beans/spring-beans.xsd">
  
      <bean id="adders" class="com.lsa.pojo.Adders">
          <property name="addres" value="漯河"/>
      </bean>
  
      <bean id="student" class="com.lsa.pojo.Student">
          <!--1.常量注入-->
          <property name="name" value="卢申澳"/>
          <!--2.bean注入,注意点：这里的值是一个引用，ref-->
          <property name="adders" ref="adders"/>
          <!--3.数组-->
          <property name="books">
              <array>
                  <value>《西游记》</value>
                  <value>《水浒传》</value>
                  <value>《红楼梦》</value>
                  <value>《三国演义》</value>
              </array>
          </property>
          <!--4.list-->
          <property name="hobbys">
              <list>
                  <value>爱小珂</value>
                  <value>看电影</value>
                  <value>听音乐</value>
                  <value>写代码</value>
              </list>
          </property>
          <!--5.map-->
          <property name="card">
              <map>
                  <entry key="身份证号" value="4127271978101922016"/>
                  <entry key="手机号" value="18739558561"/>
                  <entry key="银行卡" value="621799504000"/>
              </map>
          </property>
          <!--6.set-->
          <property name="games">
              <set>
                  <value>QQ飞车</value>
                  <value>CF</value>
              </set>
          </property>
          <!--7.null-->
          <property name="wife"><!--  value=""-->
              <null/>
          </property>
          <!--8.Properties-->
          <property name="info">
              <props>
                  <prop key="学号">2203141008</prop>
                  <prop key="url">jdbc:cterEncodTC</prop>
                  <prop key="username">root</prop>
                  <prop key="password">123456789</prop>
              </props>
          </property>
      </bean>
  
  </beans>
  

  测试结果

  Student{name='卢申澳',
  adders=Adders{addres='漯河'},
  books=[《西游记》, 《水浒传》, 《红楼梦》, 《三国演义》], 
  hobbys=[爱小珂, 看电影, 听音乐, 写代码], 
  card={身份证号=4127271978101922016, 手机号=18739558561, 银行卡=621799504000}, games=[QQ飞车, CF], wife='null', info=null}
  
  

  ​

6.3、拓展方式注入P命空间和C命名空间

P命空间和C命名空间 C是通过构造器注入,p是注入

1.使用P命名空间进行注入 就是 property

    <?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"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
        
     <!--    1.使用p命令去注入-->
    <bean id="user1" class="com.lsa.pojo.User" p:name="卢申澳" p:age="18"/>
</beans>

 注意加入:xmlns:p="http://www.springframework.org/schema/p"

测试结果

     @Test
     public void test() {
  ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");
         User user1 = context.getBean("user1", User.class);
         System.out.println(user1);
     } 


 

2.使用C命名空间 是通过构造器注入constructor-arg

pojo

private String name;
private String age;

public User() {
}

public User(String name, String age) {
    this.name = name;
    this.age = age;
}

userbeans.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--    2.使用C命令去注入 C是他是构造器注入-->
    <bean id="user2" class="com.lsa.pojo.User" c:name="zck" c:age="18"/>
    

测试结果

    @Test
    public void test() {
        ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");
        User user1 = context.getBean("user2", User.class);
        System.out.println(user1);
    }

注意:P命名和C命名需要导入插件xmlns:p=“http://www.springframework.org/schema/p”

​

​

6.4、拓展方式注入单例原型

1.单例模式(Spring默认机制)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-szCrM7kz-1671344946868)(C:\Users\卢申澳\AppData\Local\Temp\1670833610186.png)]

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

2.原型模式每次从容器中get的时候，都会产生一个新的对象

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nQmQf31V-1671344946869)(C:\Users\卢申澳\AppData\Local\Temp\1670833628903.png)]

<bean id="user2" class="com.lsa.pojo.User" c:name="zck" c:age="18" scope="prototype"/>

小结:

测试结果

@Test
public void test() {
    ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");
    User user1 = context.getBean("user2", User.class);
    User user2 = context.getBean("user2", User.class);
    System.out.println(user1 == user2);
}

单例模式中返回true

在原型模式中返回false

3.其余request,session,application这些只能在web开发中使用到

7、自动装配

1.在xml中显示的配置

2.在java中显示的配置

3.隐式的自动装配bean[重要]

7.1测试

环境搭建:一个人有两个宠物

• people

  package com.lsa.pojo;
  
  public class People {
      private Cat cat;
      private Dog dog;
      private People people;
  
      public Cat getCat() {
          return cat;
      }
  
      public void setCat(Cat cat) {
          this.cat = cat;
      }
  
      public Dog getDog() {
          return dog;
      }
  
      public void setDog(Dog dog) {
          this.dog = dog;
      }
  
      public People getPeople() {
          return people;
      }
  
      public void setPeople(People people) {
          this.people = people;
      }
  
      @Override
      public String toString() {
          return "People{" +
                  "cat=" + cat +
                  ", dog=" + dog +
                  ", people=" + people +
                  '}';
      }
  }
  
  

7.2、ByNam自动装配

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

    
    <bean id="cat" class="com.lsa.pojo.Cat"/>
    <bean id="dog" class="com.lsa.pojo.Dog"/>
        <!--
        byName:会自动在容器的上下文中查询,参照set方法的参数名，区分大小写!
       -->
    <bean id="people" class="com.lsa.pojo.People" autowire="byName">


    </bean>
</beans>

7.3、ByType自动装配

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    
    
    <bean id="cat" class="com.lsa.pojo.Cat"/>
    <bean id="dog1" class="com.lsa.pojo.Dog"/>
    <!--
   byType:会自动在容器的上下文中查询，参照对象属性类型相同的bean!
       -->
    <bean id="people" class="com.lsa.pojo.People" autowire="byType">
    </bean>

小结:就像自动注入一样

• byName:需要保证bean的id唯一,并且参照set方法的参数名，区分大小写!
• byType:需要保证bean的class唯一，并且参照对象属性类型相同的bean!

7.4、使用注解

jdk1.5开始支持注解，spring2.5开始全面支持注解。

准备工作：利用注解的方式注入属性。

1.在spring配置文件中引入context文件头

2.配置注解的支持 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"
</beans>

@Autowired

直接在属性上使用即可!也可以在set方式上使用

使用Autowired我们可以不用编写Set方法了,前提是你这个自动装配的属性在springIoC容器中存在,

且符合名字Bytype!

会先根据类型进行注入，如果容器里有很多个满足类型的实例,在根据id去查询一样的bean，如果没有一样的id名字，可以添加 @Qualifier(value = “xxx”)去对应

测试代码

public class People {
    @Autowired
    private Cat cat;
    @Autowired
    private Dog dog;
    private People people;
   public Cat getCat() {
       return cat; 
  }
   public Dog getDog() {
       return dog;
  }

2、此时配置文件内容

<context:annotation-config/>
<bean id="dog" class="com.kuang.pojo.Dog"/>
<bean id="cat" class="com.kuang.pojo.Cat"/>
<bean id="user" class="com.kuang.pojo.people"/>

测试成功

科普

@Nullable 字段标记了这个注解,说明这个字段可以为Null
//如果允许对象为null，设置required = false,默认为true
@Autowired(required = false)
private Cat cat;

如果@Autowired自动装配的环境比较复杂,自动装配无法通过一个注解[@Autowired]完成的时候我们可以使用@Qualifier(value=“xxx”)去配置@Autowired的使用，指定一个唯一的bean对象注入

    @Autowired
    @Qualifier(value = "cat1")
    private Cat cat;
    @Autowired
    @Qualifier(value = "dog1")
    private Dog dog;
    private People people;
 

beans.xml

    <context:annotation-config/>
    <bean id="cat" class="com.lsa.pojo.Cat"/>
    <bean id="cat1" class="com.lsa.pojo.Cat"/>
    <bean id="dog" class="com.lsa.pojo.Dog"/>
    <bean id="dog1" class="com.lsa.pojo.Dog"/>
    <bean id="people" class="com.lsa.pojo.People">

###Resource

• @Resource如有指定的name属性，先按指定该属性进行byName方式查找装配；
• 其次再进行默认的byName方式进行装配；
• 如果以上都不成功，则按byType的方式自动装配。
• 都不成功，则报异常。

   @Resource(name = "cat1")
    private Cat cat;
    @Resource(name = "dog1")
    private Dog dog;
    private People people;

beans.xml

<bean id="cat1" class="com.lsa.pojo.Cat"/>
    <bean id="cat2" class="com.lsa.pojo.Cat"/>
    <bean id="dog1" class="com.lsa.pojo.Dog"/>
    <bean id="dog2" class="com.lsa.pojo.Dog"/>
    <bean id="people" class="com.lsa.pojo.People">

小结:

@Autowired与@Resource异同：

• 1、@Autowired与@Resource都可以用来装配bean。都可以写在字段上，或写在setter方法上。

• 2、@Autowired默认按类型装配（属于spring规范），默认情况下必须要求依赖对象必须存在，如果要允许null 值，可以设置它的required属性为false，如：@Autowired(required=false) ，如果我们想使用名称装配可以结合@Qualifier注解进行使用

• 3、@Resource（属于J2EE复返），默认按照名称进行装配，名称可以通过name属性进行指定。如果没有指定name属性，当注解写在字段上时，默认取字段名进行按照名称查找，如果注解写在setter方法上默认取属性名进行装配。当找不到与名称匹配的bean时才按照类型进行装配。但是需要注意的是，如果name属性一旦指定，就只会按照名称进行装配。

• 它们的作用相同都是用注解方式注入对象，但执行顺序不同。@Autowired先byType，@Resource先byName。

8、使用注解开发

8.1、说明

在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:component-scan base-package="com.lsa"/>
    <!--    装载文件-->
    <context:annotation-config/>
</beans>

8.2、bean得实现

我们之前都是使用 bean 的标签进行bean注入，但是实际开发中，我们一般都会使用注解！

• 1.配置扫描那些包下得注解

  <!--指定要扫描包,这个包下得注解-->
    <context:component-scan base-package="com.lsa"/>
    <!--    装载文件-->
    <context:annotation-config/>

• 2.在指定包中增加注解

//等价于 <bean id="user" class="com.lsa.pojo.User">
//Componet组件
@Component
public class User {
  
    public String name;
}

• 3.测试

     @Test
      public void test() {
          ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
          User user = (User) context.getBean("user");
          System.out.println(user.name);
  
      }
  

  ​

8.3.属性注入

使用注解注入属性

• 1.可以不用提供set方法，直接在直接名上添加@value(“值”)

//等价于 <bean id="name" class="com.lsa.pojo.User">
//Componet组件
@Component
public class User {
    //等价于   <property name="name" value="lsa"/>
    @Value("lsa")
    public String name;
}

• 2、如果提供了set方法，在set方法上添加@value(“值”);

@Component("user")
public class User {

   public String name;

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

@Component三个衍生注解

为了更好的进行分层，Spring可以使用其它三个注解，功能一样，目前使用哪一个功能都一样。

• @Controller：web层(@Controller)

• @Service：service层(@Service)

• @Repository：dao层(@Repository)

• @Component:pojo层

  这四个注解功能都是一样得,都是将某个类装载到Spring容器中,装置Bean

8.4、自动装配注解

@Autowrie :先根据类型自动装配，如果容器里有很多个满足类型的实例,在根据id名字装配
可以添加  @Qualifier(value = "xxx")去对应
@Resource:先根据名字进行自动装配，若有指定名，按照指定的名字，若无，按照默认名装配
@Nullable:字段标记这个注解，说明这个字段可以为null

8.5、作用域

作用域:@Scope代替

属性:singleton(单例) prototype(原型)

相当于

<bean id="user2" class="com.lsa.pojo.User" scope="xxxx"/>

8.6、小结

注册bean @Component代替 ; 等价于 <bean id="user" class="com.lsa.pojo.User">

注入值@Value代替; 等价于<property name="name" value="卢申澳"/>

作用域:@Scope代替 属性: 等价于

XML与注解比较:

XML可以适用任何场景 ，结构清晰，维护方便
注解不是自己提供的类使用不了，开发简单方便
xml与注解整合开发 ：推荐最佳实践

xml管理Bean
注解完成属性注入
使用过程中， 可以不用扫描，扫描是为了类上的注解

<context:annotation-config/>装载文件

作用：

进行注解驱动注册，从而使注解生效

用于激活那些已经在spring容器里注册过的bean上面的注解，也就是显示的向Spring注册

如果不扫描包，就需要手动配置bean

如果不加注解驱动，则注入的值为null！

9、使用Java的方法配置Spring

JavaConfig 原来是 Spring 的一个子项目，它通过 Java 类的方式提供 Bean 的定义信息，在 Spring4 的版本， JavaConfig 已正式成为 Spring4 的核心功能

1.config.配置文件

package com.lsa.config;
import com.lsa.pojo.User;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

@Configuration//等价于 这个也会Spring容器托管,注册到容器中,因此他本来就是一个@Component 这是一个配置类,就和我们之前看的beans.xml
@ComponentScan("com.lsa")//就相当于  <context:component-scan base-package="com.lsa"/>
@Import(Myconfig2.class)//就等价于    <import resource="beans3.xml"/>
public class Myconfig {

    //注册一个Bean就相当于我们之前写的一个bean标签
    //这个方法得名字,就相当于bean标签中id
    //这个方法得返回值,就想相当于bean标签中得class属性
    @Bean
    public User getuser() {
        return new User();//就是但会要注入得属性
    }
}

2.pojo

package com.lsa.pojo;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component //等价于 <bean id="name" class="com.lsa.pojo.User">
public class User {
    @Value("lsa")
    private String name;

    public String getName() {
        return name;
    }

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

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

3.测试

import com.lsa.config.Myconfig;
import com.lsa.pojo.User;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Mytest {
    @Test
    public void test() {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Myconfig.class);

        User getName = context.getBean("getuser", User.class);
        User getName1 = context.getBean("user", User.class);
        System.out.println(getName.getName() == getName1.getName());

    }
}

测试结果

这个起始自动注册了两个:

一个是Component注册的实体类调用user

一个是@Bean注册的调用getuser

最后测试等于true

注解总结:

@Component代替 ; 等价于 ==<bean id="user" class="com.lsa.pojo.User">==注册bean

@Value代替; 等价于<property name="name" value="卢申澳"/>注入值

@Scope代替 属性: 等价于作用域:

@Configuration//等价于 这个也会Spring容器托管,注册到容器中,因此他本来就是一个context:annotation-config/

@Bean :注册一个Bean就相当于我们之前写的一个bean标签 这个方法得名字,就相当于bean标签中id 这个方法得返回值,就想相当于bean标签中得class属性

@Import(Myconfig2.class) //就等价于

@ComponentScan(“com.lsa”)//就相当于 <context:component-scan base-package=“com.lsa”/>

10、代理模式

为什么学习代理模式?因为AOP的底层机制就是动态代理!

代理模式分类：

• 静态代理
• 动态代理

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ca4cei8k-1671344946870)(C:\Users\卢申澳\Desktop\上课笔记\SSM\2.Spring\img\1671098841918.jpg)]

10.1、静态代理

角色分析:

• 抽象角色 : 一般使用接口或者抽象类来实现
• 真实角色 : 被代理的角色
• 代理角色 : 代理真实角色 ; 代理真实角色后 , 一般会做一些附属的操作 .
• 客户 : 使用代理角色来进行一些操作 .访问代理对象的人

代码实现

Rent.java抽象角色

//抽象角色
public interface Rent {
    public void rent();
}

Landlord.java真实角色

//房东
public class Landlord implements Rent {
    public void rent() {
        //我只想把房子租出去
        System.out.println("房屋出租家电齐全!!!!");
    }
}

Proxy.java代理角色

//代理
public class Proxy implements Rent {
    private Landlord landlord;
    public Proxy() {
    }
    public Proxy(Landlord landlord) {
        this.landlord = landlord;
    }
    public void rent() {
        landlord.rent();
        seerent();
        contract();
    }
    public void seerent() {
        System.out.println("看房子");
    }
 public void contract() {
        System.out.println("签合同");
    }
}

Client.java客户

//客户
public class Client {
    public static void main(String[] args) {
        //客户我只想租房
        //这是直接找房东出租，因为租房可能会找不到房东
        Landlord landlord = new Landlord();

        //所以我们就只能去中介公司去租房子，把租房子的事情托给中介,中介代理房东
        //房东要帮代理租房子了，但是一般会有附属操作
        //中介帮助房东
        Proxy proxy = new Proxy(landlord);
        //你去找中介租房子
        proxy.rent();
    }
}

分析：在这个过程中，你直接接触的就是中介，就如同现实生活中的样子，你看不到房东，但是你依旧租到了房东的房子通过代理，这就是所谓的代理模式，程序源自于生活，所以学编程的人，一般能够更加抽象的看待生活中发生的事情。

静态代理的好处:

• 可以使得我们的真实角色更加纯粹 . 不再去关注一些公共的事情 .
• 公共的业务由代理来完成 . 实现了业务的分工 ,
• 公共业务发生扩展时变得更加集中和方便 .

缺点 :

• 类多了 , 多了代理类 , 工作量变大了 . 开发效率降低 .

我们想要静态代理的好处，又不想要静态代理的缺点，所以 , 就有了动态代理 !

也就是说静态代理只是对接口的实现类进行代理，

而动态代理是给接口进行代理

10.2、加深理解

代码

UserService

package com.lsa.demo02;

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void select();

}

UserServiceImpl

package com.lsa.demo02;

public class UserServiceImpl implements UserService {
    public void add() {
        System.out.println("add");
    }
    public void delete() {
        System.out.println("delete");
    }
    public void update() {
        System.out.println("update");
    }
    public void select() {
        System.out.println("select");
    }
}

UserServiceImplProxy

package com.lsa.demo02;
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 select() {
        log("select");
        userService.select();
    }
    public void log(String msg) {
        System.out.println("使用的" + msg + "方法");
    }
}

测试类

package com.lsa.demo02;

public class Client {
    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl();
        UserServiceProxy userServiceProxy = new UserServiceProxy();
        //为什么传个userService给他因为在userServiceProxy中不知道这个东西是什么
        userServiceProxy.setUserService(userService);
        userServiceProxy.add();
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8XILGrDC-1671344946871)(C:\Users\卢申澳\AppData\Local\Temp\1671028263445.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VsnRT8Th-1671344946873)(C:\Users\卢申澳\Desktop\上课笔记\SSM\2.Spring\img\20201112101554344.png)]

这就是横切从上面可知,为了不在原有的代码改动通过横切去添加新功能

10.3、动态代理

• 动态代理和静态代理角色一样
• 动态代理的代理类是动态生成得,不是我们直接写好得!
• 动态代理分为两大类:基于接口得动态代理,基于类得动态代理
  • 基于接口–JDK动态代[我要使用得]
  • 基于类:cglib
  • java字节码实现:javassist

需要了解两个类:Proxy:代理, InvocationHandler:调用处理程序

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xfw88iw4-1671344946874)(C:\Users\卢申澳\AppData\Local\Temp\1671028277826.png)]

动态代理的好处

• 可以使得我们的真实角色更加纯粹 . 不再去关注一些公共的事情 .
• 公共的业务由代理来完成 . 实现了业务的分工 ,
• 公共业务发生扩展时变得更加集中和方便 .
• 一个动态代理类代理的是一个接口,一般就是对应的一类业务
• 一个动态代理类可以代理多个类,只要是实现了同一个接口即可

代码实现

ProxyInvocationHandler

package com.lsa.demo04;


import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

//自动生产代理类
public class ProxyInvocationHandler implements InvocationHandler {
    //被代理的接口
    private Object target;

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

    //生成得到代理类
    public Object getProxy() {
        //Proxy.newProxyInstance(this.getClass().getClassLoader(), 被代理的接口,)
        return Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this);

    }

    //处理代理实例并返回结果  ，被代理的人
    public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
        log(method.getName());
        //动态代理的本质,就是使用反射机制
        Object invoke = method.invoke(target, objects);
        return invoke;
    }

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

Client

package com.lsa.demo04;

import com.lsa.demo02.UserService;
import com.lsa.demo02.UserServiceImpl;

public class Client {
    public static void main(String[] args) {
        //真实角色
        UserService userService = new UserServiceImpl();
        //代理角色,不存在
        ProxyInvocationHandler handler = new ProxyInvocationHandler();
//        第一步:代理接口也就是真实对象 设置一要代理的对象
        handler.setRent(userService);
//         第二步:动态生产代理类
        UserService proxy = (UserService) handler.getProxy();
        proxy.add();
    }
}

11、AOP

11.1什么是AOP

AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QLKjjl8U-1671344946876)(C:\Users\卢申澳\Desktop\上课笔记\SSM\2.Spring\img\20201112130947442.png)]

11.2 AOP在Spring中的作用

提供声明式事务；允许用户自定义切面

横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志，安全，缓存，事务等等…
切面（ASPECT）：横切关注点被模块化的特殊对象。即，它是一个类。
通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。
目标（Target）：被通知对象。
代理（Proxy）：向目标对象应用通知之后创建的对象。
切入点（PointCut）：切面通知执行的“地点”的定义。
连接点（JointPoint）：与切入点匹配的执行点。11.2 AOP在Spring中的作用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uqZGCZ9J-1671344946877)(C:\Users\卢申澳\Desktop\上课笔记\SSM\2.Spring\img\20201112131307360.png)]

SpringAOP中，通过Advice定义横切逻辑，Spring中支持5种类型的Advice：[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DNhcsjwM-1671344946877)(C:\Users\卢申澳\Desktop\上课笔记\SSM\2.Spring\img\20201120104439637.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DfyxrXod-1671344946878)(C:\Users\卢申澳\Desktop\上课笔记\SSM\2.Spring\img\20201120104454887.png)]

11.3使用Spring实现AOP

【重点】使用AOP织入，需要导入一个依赖包！

方法一:使用原生Spring API接口【SpringAPI接口实现】

代码实现

1.log

• AfterLog

  package com.lsa.log;
  
  import org.springframework.aop.AfterReturningAdvice;
  
  import java.lang.reflect.Method;
  
  //之后
  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);
  
      }
  }
  
  

  ​

• BeforeLog

  package com.lsa.log;
  
  import org.springframework.aop.MethodBeforeAdvice;
  
  import java.lang.reflect.Method;
  
  //以前
  public class BeforeLog implements MethodBeforeAdvice {
      //method:要指向的目标对象方法
      //objects :参数
      public void before(Method method, Object[] args, Object target) throws Throwable {
          System.out.println(target.getClass().getName() + "的" + method.getName() + "被执行了");
      }
  }
  

service

​~~~java
package com.lsa.service;

public interface UserService {
public void add();

public void delete();

public void update();

public void select();

}

~~~java
package com.lsa.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 select() {
      System.out.println("查询功能");

  }
}

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://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.lsa.service.UserServiceImpl"/>
    <bean id="beforeLog" class="com.lsa.log.BeforeLog"/>
    <bean id="afterLog" class="com.lsa.log.AfterLog"/>

    <!--    配置AOP:需要导入AOP的约束-->
    <aop:config>
        <!--切入点：expression：表达式，execution(要执行的位置就是实现3类的名字！* * * * *)-->
        <aop:pointcut id="pointcut" expression="execution(* com.lsa.service.UserServiceImpl.*(..))"/>
        <!--执行环绕增加！-->
        <aop:advisor advice-ref="beforeLog" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>
</beans>

测试

import com.lsa.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;


public class Mytest09 {
    @Test
    public void test() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = (UserService) context.getBean("userService");
        userService.add();

    }
}

方法二:自定义类实现AOP【主要是切面定义】

diyPointCut.java

public class diyPointCut {
    public void before() {
        System.out.println("=================在功能前切入==========");
    }

    public void after() {
        System.out.println("=================在功能后切入==========");
    }
}

beans.xml

<!--注册bean-->
   
    <bean id="diy" class="com.lsa.diy.diyPointCut"/>
    <bean id="beforeLog" class="com.lsa.log.BeforeLog"/>
    <bean id="afterLog" class="com.lsa.log.AfterLog"/>
    <aop:config>
        <aop:aspect ref="diy">
            <aop:pointcut id="pointcut" expression="execution(* com.lsa.service.*.*(..))"/>
            <aop:before method="before" pointcut-ref="pointcut"/>
            <aop:after method="after" pointcut-ref="pointcut"/>
        </aop:aspect>
    </aop:config>

测试和service与上面一样

方式三:使用注解[就是方法二使用了注解的方式]

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://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.lsa.service.UserServiceImpl"/>
    <bean id="diy" class="com.lsa.diy.diyPointCut"/>
    <bean id="beforeLog" class="com.lsa.log.BeforeLog"/>
    <bean id="afterLog" class="com.lsa.log.AfterLog"/>
    <!--方法三-->
    <bean id="annotationPoinCut" class="com.lsa.diy.AnnotationPoinCut"/>
    <!--   开启注解支持! JDK(默认proxy-target-class="false"  ) cglib(proxy-target-class="true") -->
    <aop:aspectj-autoproxy/>

</beans>

AnnotationPoinCut

package com.lsa.diy;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect//标注这个点是切面
public class AnnotationPoinCut {
    @Before("execution(* com.lsa.service.UserServiceImpl.*(..))")
    public void before() {
        System.out.println("=========方执行前=======");
    }

    @After("execution(* com.lsa.service.UserServiceImpl.*(..))")
    public void after() {
        System.out.println("=========方执行后=======");
    }

    @Around("execution(* com.lsa.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕前");
        joinPoint.proceed();
        System.out.println("环绕后");
    }
}

测试类与上面一样

结果

环绕前
=========方执行前=======
添加功能
=========方执行后=======
环绕后

12、整合Mybatis

12.1、回顾Mybatis

步骤：

1. 导入相关jar包

   • junit

   • mybatis

   • mysql数据库

   • spring相关

   • aop织入器

   • mybatis-spring整合包【重点】在此还导入了lombok包。

   • 配置Maven静态资源过滤问题！

       <dependencies>
             <!--测试-->
             <dependency>
                 <groupId>junit</groupId>
                 <artifactId>junit</artifactId>
                 <version>4.12</version>
             </dependency>
             <!--mybatis-->
             <dependency>
                 <groupId>org.mybatis</groupId>
                 <artifactId>mybatis</artifactId>
                 <version>3.5.6</version>
             </dependency>
             <!--   mysql    -->
             <dependency>
                 <groupId>mysql</groupId>
                 <artifactId>mysql-connector-java</artifactId>
                 <version>8.0.28</version>
             </dependency>
             <!--spring-->
             <dependency>
                 <groupId>org.springframework</groupId>
                 <artifactId>spring-webmvc</artifactId>
                 <version>5.2.0.RELEASE</version>
             </dependency>
             <!--Spring操作数据库的话，还需要一个spring-jdbc -->
             <dependency>
                 <groupId>org.springframework</groupId>
                 <artifactId>spring-jdbc</artifactId>
                 <version>5.2.0.RELEASE</version>
             </dependency>
             <dependency>
                 <groupId>org.aspectj</groupId>
                 <artifactId>aspectjweaver</artifactId>
                 <version>1.8.13</version>
             </dependency>
             <!--mybatis-spring-->
             <dependency>
                 <groupId>org.mybatis</groupId>
                 <artifactId>mybatis-spring</artifactId>
                 <version>2.0.2</version>
             </dependency>
             <!--偷懒工具-->
             <dependency>
                 <groupId>org.projectlombok</groupId>
                 <artifactId>lombok</artifactId>
                 <version>1.18.10</version>
             </dependency>
     
         </dependencies>
     
         <build>
             <resources>
                 <resource>
                     <directory>src/main/java</directory>
                     <includes>
                         <include>**/*.properties</include>
                         <include>**/*.xml</include>
                     </includes>
                     <filtering>true</filtering>
                 </resource>
             </resources>
         </build>
     

     ​

2.编写配置文件mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <!--引入外部配置文件-->
    <properties resource="db.properties"/>

    <settings>
        <!--默认日志-->
        <setting name="logImpl" value="STDOUT_LOGGING"/>
        <!-- 显示的开启缓存，但是写上可以让看代码的人明白 -->
        <setting name="cacheEnabled" value="true"/>
        <!--开启将数据库中的下划线命名法改成java的驼峰命名法 如果是只差一个下划线可以用-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>
    <!-- 第一种：直接定义到实体包名上 alias后面写别名-->
    <!--    <typeAliases>-->
    <!--        <typeAlias type="com.lsa.pojo.Blog" alias="blog"/>-->
    <!--    </typeAliases>-->

    <!-- 第二种：直接扫描一个包目录下 默认名为包名小写 如需自定义名在实体类中 @Alias()-->
    <typeAliases>
        <package name="com.lsa.pojo"/>
    </typeAliases>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${root}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
    <!--        每一个mapper.xml都需要在Mybatis核心配置文件中注册-->
    <mappers>
        <mapper class="com.lsa.dao.UserMapper"/>
    </mappers>
</configuration>

3.实体类

package com.lsa.pojo;

import lombok.Data;
import org.apache.ibatis.type.Alias;

@Data
@Alias("User")
public class User {
    private int id;
    private String name;
    private String pwd;
}

4.编写UserMapper接口

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

5.编写UserMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--namespace = 中的包名，要和接口一致-->

<mapper namespace="com.lsa.dao.UserMapper">
    <select id="UserList" resultType="User">
        select * from user
    </select>
</mapper>

12.2 Mybatis-Spring

什么是MyBatis-Spring？

MyBatis-Spring 会帮助你将 MyBatis 代码无缝地整合到 Spring 中。

如果使用 Maven 作为构建工具，仅需要在 pom.xml 中加入以下代码即可：

<!--mybatis-spring-->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>2.0.2</version>
</dependency>

整合实现一:

1.引入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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
</beans>

2.在spring中配置数据源

  <!--数据源配置DataSource:使用Spring的数据源替换Mybatis的配置 c3p0 dbcp druid 我们这里使用Spring提供高的JDBC:-->
    <bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url"
                  value="jdbc:mysql://localhost:3306/mybatis01?useSSL=false&amp;useUnicode=true&amp;characterEncoding=utf8&amp;serverTimezone=GMT%2B8"/>
        <property name="username" value="root"/>
        <property name="password" value="123456789"/>
    </bean>

3.配置sqlSessionFactory，关联Mybatis

  <!--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/lsa/mapper/*.xml"/>
    </bean>

4.注册SqlSessionTemplate 关联sqlSessionFactory

<!--SqlSessionTemplate:就是我们使用徳sqlSession-->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <!--只能使用构造器注入SqlSessionFactory，因为他没用set-->
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>

5.需要UserMapper接口的UserMapperImpl 实现类，私有化sqlSessionTemplate

package com.lsa.mapper
import com.lsa.pojo.User;
import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.List;
public class UserMapperImpl implements UserMapper {
    @Autowired
    private SqlSessionTemplate sqlSession;

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

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

6.将建立的实体类注册到bean中

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

7.mybatis中的配置

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!--引入外部配置文件-->
    <properties resource="db.properties"/>
    <settings>
        <!--默认日志-->
        <setting name="logImpl" value="STDOUT_LOGGING"/>
        <!-- 显示的开启缓存，但是写上可以让看代码的人明白 -->
        <setting name="cacheEnabled" value="true"/>
        <!--开启将数据库中的下划线命名法改成java的驼峰命名法 如果是只差一个下划线可以用-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>
    <!-- 第一种：直接定义到实体包名上 alias后面写别名-->
    <!--    <typeAliases>-->
    <!--        <typeAlias type="com.lsa.pojo.Blog" alias="blog"/>-->
    <!--    </typeAliases>-->

    <!-- 第二种：直接扫描一个包目录下 默认名为包名小写 如需自定义名在实体类中 @Alias()-->
    <typeAliases>
        <package name="com.lsa.pojo"/>
    </typeAliases>
</configuration>

7.测试

   @Test
    public void test() throws IOException {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-dao.xml");
        UserMapper mapper = context.getBean("userMapper", UserMapper.class);
        for (User user : mapper.UserList()) {
            System.out.println(user);
        }
    }

测试过程中出现的错误

在spring中绑定了mybaits的配置文件记得在mybatis中删除

创建完实体类的注入

方法二：继承SqlSessionDaoSupport

mybatis-spring1.2.3版以上的才有这个，官方文档截图：

dao继承Support类 , 直接利用 getSqlSession() 获得 , 然后直接注入SqlSessionFactory . 比起整合方式一 , 不需要管理SqlSessionTemplate , 而且对事务的支持更加友好 . 可跟踪源码查看。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rMLkpnUc-1671344946880)(C:\Users\卢申澳\AppData\Local\Temp\1671288108927.png)]

1.将我们上面写的UserMapperImpl修改如下

public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper {
    public List<User> UserList() {
        return getSqlSession().getMapper(UserMapper.class).UserList();
    }
}

2.注册到Spring

  <bean id="userMapper2" class="com.lsa.mapper.UserMapperImpl2">
        <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
    </bean>

3.测试

  ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserMapper mapper = context.getBean("userMapper2", UserMapper.class);
        for (User user : mapper.UserList()) {
            System.out.println(user);
        }
    }

这两种方法第一种，注册SqlSessionTemplate绑定sqlsessionfatory然后自己写set注入

第二种是继承SqlSessionDaoSupport 别人已经写好SqlSessionTemplate，然后你只需要注入sqlsessionfatory就行

13、声明式事务

13.1、回顾事务

• 把一组业务当成一个业务来做;要么都成功，要么都失败

• 事务在数据开发中，十分重要，涉及到数据的一直性问题，不能马虎!

• 确保完整性和一致性;

  ​

事务的ACID原则

• 原子性

• 一致性

  • 就是要保持数据的统一

• 隔离性

  • 多个事务可能操作同一个资源，防止损坏

• 持久性

  • 事务一旦提交无论系统发生什么问题，结果都不会再被影响，被持久化

  ​

测试：

将上面的代码拷贝到一个新项目中
在之前的案例中，我们给userMapper接口新增两个方法，删除和增加用户；

    //添加
    public int addUser(User user);
    //删除
    public int deleteUser(@Param("id") Integer id);

UserMapper.xml

故意将from写成form

 <insert id="addUser" parameterType="User">
        insert into user(id,name,pwd) values(#{id},#{name},#{pwd})
    </insert>
    <delete id="deleteUser" parameterType="Integer">
        delete form user where id = #{id}
    </delete>

UserMapperImpl.java

package com.lsa.mapper;

import com.lsa.pojo.User;
import org.mybatis.spring.support.SqlSessionDaoSupport;

import java.util.List;

public class UserMapperImpl extends SqlSessionDaoSupport implements UserMapper {
    public List<User> UserList() {
        User user = new User(7, "小卢", "123456");
        UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
        mapper.addUser(user);
        mapper.deleteUser(7);
        return mapper.UserList();
    }
    public int addUser(User user) {
        return getSqlSession().getMapper(UserMapper.class).addUser(user);
    }
    public int deleteUser(Integer id) {
        return getSqlSession().getMapper(UserMapper.class).deleteUser(id);
    }
}

测试

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

报错：sql异常，form写错了

结果 ：数据库结果显示插入成功！

没有进行事务的管理；我们想让他们都成功才成功，有一个失败，就都失败，我们就应该需要事务！

以前我们都需要自己手动管理事务，十分麻烦！

但是Spring给我们提供了事务管理，我们只需要配置即可；

13.2 Spring中的事务管理

Spring在不同的事务管理API之上定义了一个抽象层，使得开发人员不必了解底层的事务管理API就可以使用Spring的事务管理机制。Spring支持编程式事务管理和声明式的事务管理。

编程式事务管理

• 将事务管理代码嵌到业务方法中来控制事务的提交和回滚

• 缺点：必须在每个事务操作业务逻辑中包含额外的事务管理代码

声明式事务管理

一般情况下比编程式事务好用。

• 将事务管理代码从业务方法中分离出来，以声明的方式来实现事务管理。

• 将事务管理作为横切关注点，通过aop方法模块化。

• Spring中通过Spring AOP框架支持声明式事务管理。

  ​

1.在SPring中开启配置声明式事务

绑定数据源

  <!--1.开启配置声明式事务-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="datasource"/>
    </bean>

2.结合AOP给方法配置事务

  <!--结合Aop实现事务织入-->
    <!--配置事务通知-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <!--给那些方法配置事务-->
        <!--配置事务的传播特性 :new propation =-->
        <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>

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-02AZCNbj-1671344946881)(C:\Users\卢申澳\Desktop\上课笔记\SSM\2.Spring\img\302835a62a00cb506dff0f0ae17eeaa.png)]

3.配置事务切入

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

其他配置一样只是在原有基础加上这些

重点 5.6.7代码

结语:希望自己能够向着内心的方向出发！！！