spring基础

Spring

概述及IOC理论推导

优点：

• spring是一个开源免费框架
• spring是一个轻量级框架，非侵入式的
• 控制反转IOC，面向切面编程AOP
• 对事物的支持，对框架的支持

spring是一个轻量级的控制反转（IOC）和面向切面编程（AOP）的容器（框架）

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

spring7个模块：

• 核心容器：核心容器提供了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。

Spring Boot与Spring Cloud

• Spring Boot 是 Spring 的一套快速配置脚手架，可以基于Spring Boot 快速开发单个微服务;
• Spring Cloud是基于Spring Boot实现的；
• Spring Boot专注于快速、方便集成的单个微服务个体，Spring Cloud关注全局的服务治理框架；
• Spring Boot使用了约束优于配置的理念，很多集成方案已经帮你选择好了，能不配置就不配置 , Spring Cloud很大的一部分是基于Spring Boot来实现，Spring Boot可以离开Spring Cloud独立使用开发项目，但是Spring Cloud离不开Spring Boot，属于依赖的关系。
• SpringBoot在SpringClound中起到了承上启下的作用，如果你要学习SpringCloud必须要学习SpringBoot。

IOC理论推导：

新建一个maven项目：

1. 先写一个UserDao接口：

   public interface UserDao{
       public void getUser();
   }
   

2. 写dao的实现类

   public class UserDaoImpl implements UserDao {
       @Override
       public void getUser(){
           System.out.println("获取用户数据")；
       }
   }
   

3. 再去写UserService的接口

   public interface UserService{
       public void getUser();
   }
   

4. 写Service的实现类

   public class UserServiceImpl implements UserService {
      private UserDao userDao = new UserDaoImpl();
   
      @Override
      public void getUser() {
          userDao.getUser();
     }
   }
   

5. 测试一下

   @Test
   public void test(){
      UserService service = new UserServiceImpl();
      service.getUser();
   }
   

如果将Userdao 的实现类增加一个，就需要去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的一种方法。

没有IOC的程序中，使用面向对象编程，对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转给第三方，控制反转就是：获得依赖对象的方式反转了。

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

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

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

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

快速上手Spring

HelloSpring

导入jar包依赖

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

1. 编写一个Hello实现类

   public class Hello{
       private String name;
       
       public String getName(){
           return name;
       }
       public void setName(String name){
           this.name = name;
       }
       
       public void show(){
           System.out.println("Hello,"+name);
       }
   }
   

2. 编写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
          http://www.springframework.org/schema/beans/spring-beans.xsd">
   
   <!--bean就是java对象 , 由Spring创建和管理-->
   <bean id="hello" class="com.kuang.pojo.Hello">
          <property name="name" value="Spring"/>
      </bean>
   
   </beans>
   

3. 进行测试

   @Test
   public void test(){
       //解析beans.xml文件，生成管理相应的bean对象
       ApplicationContext context new ClassPathXmlApplicationContext("beans.xml");
       //getBean:参数即为spring配置文件的bean的id
       Hello hello = (Hello)context.getBean("hello");
      hello.show();
   }
   

   Hello对象是谁创建的？hello对象是由Spring创建的

   Hello对象的属性是怎么设置的？hello对象的属性是由spring容器设置的

这个过程就叫做控制反转:

• 控制：谁来控制对象的创建，传统应用程序是由程序本身控制创建的，使用Spring后，对象由Spring进行创建
• 反转：程序本身不创建对象，而变为被动的接收对象

依赖注入：就是利用set方法进行注入的

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

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

在案例一中，新增一个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
       http://www.springframework.org/schema/beans/spring-beans.xsd">

   <bean id="MysqlImpl" class="com.kuang.dao.impl.UserDaoMySqlImpl"/>
   <bean id="OracleImpl" class="com.kuang.dao.impl.UserDaoOracleImpl"/>

   <bean id="ServiceImpl" class="com.kuang.service.impl.UserServiceImpl">
       <!--注意: 这里的name并不是属性 , 而是set方法后面的那部分 , 首字母小写-->
       <!--引用另外一个bean , 不是用value 而是用 ref-->
       <property name="userDao" ref="OracleImpl"/>
   </bean>

</beans>

测试

@Test
public void test2(){
   ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
   UserServiceImpl serviceImpl = (UserServiceImpl) context.getBean("ServiceImpl");
   serviceImpl.getUser();
}

现在就不需要再到程序中进行修改了，要实现不同的操作，只需要在xml配置文件中进行修改，所谓IOC就是：对象由Spring进行创建、管理、装配。

IOC创建对象的方式

通过无参构造方法进行创建

1. User.java

   public class User{
       
       private String name;
       
       public User(){
           System.out.println("user无参构造方法")；
       }
       
       public void setName(String name){
           this.name=name;
       }
       
       public void show(){
           System.out.println("name="+name);
       }
   }
   

2. 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
          http://www.springframework.org/schema/beans/spring-beans.xsd">
   
      <bean id="user" class="com.kuang.pojo.User">
          <property name="name" value="kuangshen"/>
      </bean>
   
   </beans>
   

3. 测试类

   @Test
   public void test(){
      ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
      //在执行getBean的时候, user已经创建好了 , 通过无参构造
      User user = (User) context.getBean("user");
      //调用对象的方法 .
      user.show();
   }
   

结果可以发现，在调用show方法之前，User对象已经通过无参构造初始化了！

通过有参构造方法来创建

1. UserT.java

   public class UserT {
   
      private String name;
   
      public UserT(String name) {
          this.name = name;
     }
   
      public void setName(String name) {
          this.name = name;
     }
   
      public void show(){
          System.out.println("name="+ name );
     }
   
   }
   

2. beans.xml有三种方式编写

<!-- 第一种根据index参数下标设置 -->
<bean id="userT" class="com.kuang.pojo.UserT">
   <!-- index指构造方法 , 下标从0开始 -->
   <constructor-arg index="0" value="kuangshen2"/>
</bean>

<!-- 第二种根据参数名字设置 -->
<bean id="userT" class="com.kuang.pojo.UserT">
   <!-- name指参数名 -->
   <constructor-arg name="name" value="kuangshen2"/>
</bean>

<!-- 第三种根据参数类型设置 -->
<bean id="userT" class="com.kuang.pojo.UserT">
   <constructor-arg type="java.lang.String" value="kuangshen2"/>
</bean>

3. 测试

@Test
public void testT(){
   ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
   UserT user = (UserT) context.getBean("userT");
   user.show();
}

在配置文件加载时，其中管理对象都已经开始初始化了

Spring配置

别名

alias 设置别名 , 为bean设置别名 , 可以设置多个别名

<!--设置别名：在获取Bean的时候可以使用别名获取-->
<alias name="userT" alias="userNew"/>

Bean的配置

<!--bean就是java对象,由Spring创建和管理-->

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

class是bean的全限定名=包名+类名
-->
<bean id="hello" name="hello2 h2,h3;h4" class="com.kuang.pojo.Hello">
   <property name="name" value="Spring"/>
</bean>

import

团队合作通过import来实现

<import resource="{path}/beans.xml"/>

依赖注入

• 依赖：指bean对象的创建依赖于容器，bean对象的依赖资源
• 注入：指bean对象所依赖的资源，由容器来设置和装配

构造器注入

之前有

set注入

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

测试pojo类:

Address.java

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

Student.java

 package com.kuang.pojo;
 
 import java.util.List;
 import java.util.Map;
 import java.util.Properties;
 import java.util.Set;
 
 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;
 
     public void setName(String name) {
         this.name = name;
    }
 
     public void setAddress(Address address) {
         this.address = address;
    }
 
     public void setBooks(String[] books) {
         this.books = books;
    }
 
     public void setHobbys(List<String> hobbys) {
         this.hobbys = hobbys;
    }
 
     public void setCard(Map<String, String> card) {
         this.card = card;
    }
 
     public void setGames(Set<String> games) {
         this.games = games;
    }
 
     public void setWife(String wife) {
         this.wife = wife;
    }
 
     public void setInfo(Properties info) {
         this.info = info;
    }
 
     public void show(){
         System.out.println("name="+ name
                 + ",address="+ address.getAddress()
                 + ",books="
        );
         for (String book:books){
             System.out.print("<<"+book+">>\t");
        }
         System.out.println("\n爱好:"+hobbys);
 
         System.out.println("card:"+card);
 
         System.out.println("games:"+games);
 
         System.out.println("wife:"+wife);
 
         System.out.println("info:"+info);
 
    }
 }

1. 常量注入

   <bean id="student" class="com.kuang.pojo.Student">
        <property name="name" value="小明"/>
    </bean>
   

   测试：

   @Test
    public void test01(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    
        Student student = (Student) context.getBean("student");
    
        System.out.println(student.getName());
    
    }
   

2. Bean注入

   注意点：这里的值是一个引用，ref

   <bean id="addr" class="com.kuang.pojo.Address">
        <property name="address" value="重庆"/>
    </bean>
    
    <bean id="student" class="com.kuang.pojo.Student">
        <property name="name" value="小明"/>
        <property name="address" ref="addr"/>
    </bean>
   

3. 数组注入

   <bean id="student" class="com.kuang.pojo.Student">
        <property name="name" value="小明"/>
        <property name="address" ref="addr"/>
        <property name="books">
            <array>
                <value>西游记</value>
                <value>红楼梦</value>
                <value>水浒传</value>
            </array>
        </property>
    </bean>
   

4. List注入

    <property name="hobbys">
        <list>
            <value>听歌</value>
            <value>看电影</value>
            <value>爬山</value>
        </list>
    </property>
   

5. Map

   <property name="card">
        <map>
            <entry key="中国邮政" value="456456456465456"/>
            <entry key="建设" value="1456682255511"/>
        </map>
    </property>
   

6. set注入

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

7. Null注入

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

8. properties注入

   <property name="info">
        <props>
            <prop key="学号">20190604</prop>
            <prop key="性别">男</prop>
            <prop key="姓名">小明</prop>
        </props>
    </property>
   

   测试结果：

p命名和c命名注入

User.java ：【注意：这里没有有参构造器！】

public class User {
     private String name;
     private int age;
 
     public void setName(String name) {
         this.name = name;
    }
 
     public void setAge(int age) {
         this.age = age;
    }
 
     @Override
     public String toString() {
         return "User{" +
                 "name='" + name + '\'' +
                 ", age=" + age +
                 '}';
    }
 }

1. P命名空间注入 : 需要在头文件中加入约束文件

   导入约束 : xmlns:p="http://www.springframework.org/schema/p"
    
    <!--P(属性: properties)命名空间 , 属性依然要设置set方法-->
    <bean id="user" class="com.kuang.pojo.User" p:name="狂神" p:age="18"/>
   

2. c 命名空间注入 : 需要在头文件中加入约束文件

   导入约束 : xmlns:c="http://www.springframework.org/schema/c"
    <!--C(构造: Constructor)命名空间 , 属性依然要设置set方法-->
    <bean id="user" class="com.kuang.pojo.User" c:name="狂神" c:age="18"/>
   

   发现问题：爆红了，刚才我们没有写有参构造！

   解决：把有参构造器加上，这里也能知道，c 就是所谓的构造器注入！

   测试代码：

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

Bean的作用域

在spring中，那些组成应用程序的主体及由spring ioc容器所管理的对象，被称之为bean。

简单地说，bean就是由IOC容器初始化、装配及管理的对象。

类别	说明
singleton	在spring IOC容器中仅存在一个bean实例，bean以单例方式存在，默认值
prototype	每次从容器中调用bean时，都返回一个新的实例，即每次调用getBean（）时，相当于执行new XxxBean()
request	每次Http 请求都会创建一个新的bean，该作用域仅适用于WebApplicationContext环境
session	同一个HTTP Session共享一个Bean，不同Session使用不同Bean，仅适用于WebApplicationContext环境

几种作用域中，request、session作用域仅在基于web的应用中使用（不必关心你所采用的是什么web应用框架），只能用在基于web的Spring ApplicationContext环境。

Singleton

当一个bean的作用域为Singleton，那么Spring IoC容器中只会存在一个共享的bean实例，并且所有对bean的请求，只要id与该bean定义相匹配，则只会返回bean的同一实例。Singleton是单例类型，就是在创建起容器时就同时自动创建了一个bean的对象，不管你是否使用，他都存在了，每次获取到的对象都是同一个对象。注意，Singleton作用域是Spring中的缺省作用域。要在XML中将bean定义成singleton，可以这样配置：

<bean id="ServiceImpl" class="cn.csdn.service.ServiceImpl" scope="singleton">

测试：

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

Prototype

当一个bean的作用域为Prototype，表示一个bean定义对应多个对象实例。Prototype作用域的bean会导致在每次对该bean请求（将其注入到另一个bean中，或者以程序的方式调用容器的getBean()方法）时都会创建一个新的bean实例。Prototype是原型类型，它在我们创建容器的时候并没有实例化，而是当我们获取bean的时候才会去创建一个对象，而且我们每次获取到的对象都不是同一个对象。根据经验，对有状态的bean应该使用prototype作用域，而对无状态的bean则应该使用singleton作用域。在XML中将bean定义成prototype，可以这样配置：

<bean id="account" class="com.foo.DefaultAccount" scope="prototype"/>  
  或者
 <bean id="account" class="com.foo.DefaultAccount" singleton="false"/>

Request

当一个bean的作用域为Request，表示在一次HTTP请求中，一个bean定义对应一个实例；即每个HTTP请求都会有各自的bean实例，它们依据某个bean定义创建而成。该作用域仅在基于web的Spring ApplicationContext情形下有效。考虑下面bean定义：

 <bean id="loginAction" class=cn.csdn.LoginAction" scope="request"/>

针对每次HTTP请求，Spring容器会根据loginAction bean的定义创建一个全新的LoginAction bean实例，且该loginAction bean实例仅在当前HTTP request内有效，因此可以根据需要放心的更改所建实例的内部状态，而其他请求中根据loginAction bean定义创建的实例，将不会看到这些特定于某个请求的状态变化。当处理请求结束，request作用域的bean实例将被销毁。

Session

当一个bean的作用域为Session，表示在一个HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。考虑下面bean定义：

<bean id="userPreferences" class="com.foo.UserPreferences" scope="session"/>

针对某个HTTP Session，Spring容器会根据userPreferences bean定义创建一个全新的userPreferences bean实例，且该userPreferences bean仅在当前HTTP Session内有效。与request作用域一样，可以根据需要放心的更改所创建实例的内部状态，而别的HTTP Session中根据userPreferences创建的实例，将不会看到这些特定于某个HTTP Session的状态变化。当HTTP Session最终被废弃的时候，在该HTTP Session作用域内的bean也会被废弃掉。

自动装配

自动装配是spring满足bean依赖的一种方法

spring会在应用上下文为某个bean寻找其依赖的bean

Spring中bean有三种装配机制，分别是：

1. 在xml中显示装配
2. 在Java中显示装配
3. 隐式的bean发现机制和自动装配

主要学习第三种：自动化的装配bean

Spring的自动装配要从两个角度来实现：

1. 组件扫描（component scanning）:spring会自动发现应用上下文所创建的bean；
2. 自动装配（autowring）:spring自动满足bean之间的依赖，也就是说所的IOC/DI；

组件扫描和自动装配组合发挥巨大威力，使得显示的配置降低到最少。

推荐不使用自动装配xml，而使用注解。

测试环境搭建

1. 新建一个项目

2. 新建两个实体类，Cat,Dog都有一个叫的方法。

   public class Cat{
       public void shout(){
           System.out.println("miao~")
       }
   }
   

   public class Dog{
       public void shout(){
           System.out.println("wang~")
       }
   }
   

3. 新建一个用户类User

   public class User{
       private Cat cat;
       private Dog dog;
       private String str;
   }
   

4. 编写Spring配置文件

   <?xml version="1.0" encoding="UTF-8"?>
   <beans xmlns="http://www.springframework.org/schema/beans"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.springframework.org/schema/beans
          http://www.springframework.org/schema/beans/spring-beans.xsd">
   
      <bean id="dog" class="com.kuang.pojo.Dog"/>
      <bean id="cat" class="com.kuang.pojo.Cat"/>
   
      <bean id="user" class="com.kuang.pojo.User">
          <property name="cat" ref="cat"/>
          <property name="dog" ref="dog"/>
          <property name="str" value="qinjiang"/>
      </bean>
   </beans>
   

5. 测试

   public class MyTest {
      @Test
      public void testMethodAutowire() {
          ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
          User user = (User) context.getBean("user");
          user.getCat().shout();
          user.getDog().shout();
     }
   }
   

   结果正常输出，环境OK

byname

autowire byname(按名称自动装配)

由于在手动配置xml过程中，常常发生字母缺漏和大小写等错误，而无法对其进行检查，使得开发效率降低。

采用自动装配将避免这些错误，并且使配置简单化。

测试：

1. 修改bean配置，增加一个属性 autowire="byname"

   <bean id="user" class="com.kuang.pojo.User" autowire="byName">
      <property name="str" value="qinjiang"/>
   </bean>
   

2. 再次测试，结果依然成功输出

3. 将cat的bean id修改为 catXXX

4. 再次测试， 执行时报空指针java.lang.NullPointerException。因为按byName规则找不对应set方法，真正的setCat就没执行，对象就没有初始化，所以调用时就会报空指针错误。

小结：

当一个bean节点带有 autowire byName的属性时。

1. 将查找其类中所有的set方法名，例如setCat，获得将set去掉并且首字母小写的字符串，即cat。
2. 去spring容器中寻找是否有此字符串名称id的对象。
3. 如果有，就取出注入；如果没有，就报空指针异常。

byType

autowire byType (按类型自动装配)

使用autowire byType首先需要保证：同一类型的对象，在spring容器中唯一。如果不唯一，会报不唯一的异常。

NoUniqueBeanDefinitionException

测试：

1. 将user的bean配置修改一下 ： autowire="byType"

2. 测试，正常输出

3. 在注册一个cat 的bean对象！

   <bean id="dog" class="com.kuang.pojo.Dog"/>
   <bean id="cat" class="com.kuang.pojo.Cat"/>
   <bean id="cat2" class="com.kuang.pojo.Cat"/>
   
   <bean id="user" class="com.kuang.pojo.User" autowire="byType">
      <property name="str" value="qinjiang"/>
   </bean>
   

4. 测试，报错：NoUniqueBeanDefinitionException

5. 删掉cat2，将cat的bean名称改掉！测试！因为是按类型装配，所以并不会报异常，也不影响最后的结果。甚至将id属性去掉，也不影响结果。

使用注解

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

准备工作：

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

   xmlns:context="http://www.springframework.org/schema/context"
   
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context.xsd
   

2. 开启属性注解支持

   <context:annotation-config/>
   

@Autowired

• @Autowired是按类型自动转配的，不支持id匹配。
• 需要导入 spring-aop的包

测试：

1. 将User类中的set方法去掉，使用@Autowired注解

   public class User{
       @Autowired
       private Cat cat;
       @Autowired
       private Dog dog;
       private String str;
       
       public Cat getCat(){
           return cat;
       }
       public Dog getDog(){
           return dog;
       }
       public String getStr(){
           return str;
       }
   }
   

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.User"/>
   

3. 测试，成功输出结果。

@Autowired(required=false) 说明：false，对象可以为null；true，对象必须存对象，不能为null。

//如果允许对象为null，设置required = false,默认为true
@Autowired(required = false)
private Cat cat;

@Qualifier

• @Autowired是根据类型自动装配的，加上@Qualifier则可以根据byName的方式自动装配
• @Qualifier不能单独使用

测试实验步骤：

1. 配置文件修改内容，保证类型存在对象，且名字不为类的默认名字

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

2. 没有加Qualifier测试，直接报错

3. 在属性上添加Qualifier注解

   @Autowired
   @Qualifier(value = "cat2")
   private Cat cat;
   @Autowired
   @Qualifier(value = "dog2")
   private Dog dog;
   

   测试，成功输出！

@Resource

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

实体类：

public class User{
    //如果允许对象为null,设置required = false，默认为true
    @Resource(name = "cat2")
    private Cat cat;
    @Resource
    private Dog dog;
    private String str;
}

beans.xml

<bean id="dog" class="com.kuang.pojo.Dog"/>
<bean id="cat1" class="com.kuang.pojo.Cat"/>
<bean id="cat2" class="com.kuang.pojo.Cat"/>

<bean id="user" class="com.kuang.pojo.User"/>

测试结果为OK

配置文件2：beans.xml,删掉cat2

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

实体类上只保留注解

@Resource
private Cat cat;
@Resource
private Dog dog;

结果：OK

结论：先进行byName查找，失败；在进行byType查找，成功

小结：

@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

使用注解开发

想要使用注解形式，必须要引入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
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">

</beans>

Bean的使用

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

1. 配置扫描哪些包下是注解

   <!--指定注解扫描包-->
   <context:component-scan base-package="com.kuang.pojo"/>
   

2. 在指定包下编写类，增加注解

   @Component("user")
   //相当于配置文件中<bean id = "user" class = "当前注解的类">
   public class User{
       public String name = "秦疆"；
   }
   

3. 测试

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

属性注入

使用注解注入属性

1. 可以不用提供set方法，直接在直接名上添加@value（"值"）

   @Component("user")
   // 相当于配置文件中 <bean id="user" class="当前注解的类"/>
   public class User {
      @Value("秦疆")
      // 相当于配置文件中 <property name="name" value="秦疆"/>
      public String name;
   }
   

2. 如果提供了set方法，在set方法上添加@value("值")

   @Conponent("user")
   public class User{
       public String name;
       
       @Value("秦疆")
       public void setName(String name){
           this.name = name;
       }
   }
   

衍生注解

这些注解只是替代了在配置文件当中配置步骤而已，更加方便便捷

@Component三个衍生注解

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

• @Controller: web层
• @Service: service层
• @Respository: dao层

写上这些注解相当于将这个类交给了spring管理装配了

作用域

@scope

• singleton：默认的，Spring会采用单例模式创建这个对象。关闭工厂 ，所有的对象都会销毁。
• prototype：多例模式。关闭工厂 ，所有的对象不会销毁。内部的垃圾回收机制会回收

@Controller("user")
@Scope("propototype")
public class User{
    @Value("秦疆")
    public String name;
}

小结：

xml于注解比较

• xml可以适用任何场景，结构清晰，维护方便
• 注解不是自己提供的类使用不了，开发简单方便

xml与注解整合开发：推荐最佳实践

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

<context:annotation-config/> 

作用：

• 进行注解驱动注册，从而使注解失效
• 用于激活那些已经在spring容器里注册过的bean上面的注解，也就是显示向spring注册
• 如果不扫描包，就需要手动配置bean
• 如果不加注释驱动，则注入的值为null

基于Java类进行配置

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

测试：

1. 编写一个实体类，Dog

   @Component //将这个类标注为Spring的一个组件，放到容器中
   public class Dog{
       public String name = "doge";
   }
   

2. 新建一个config配置包，编写一个MyConfig配置类

   @Configuration  //代表这是一个配置类
   public class Myconfig{
       @Bean //通过方法注册一个bean，这里的返回值就是Bean类型，方法名就是备的id!
       public Dog dog(){
           return new Dog();
       }
   }
   

3. 测试

   @Test
   public void test2(){
        ApplicationContext applicationContext =
              new AnnotationConfigApplicationContext(MyConfig.class);
      Dog dog = (Dog) applicationContext.getBean("dog");
      System.out.println(dog.name);
   }
   

4. 成功输出结果

导入其他配置

1. 再编写一个配置类

   @Configuration //代表是一个配置类
   public class MyConfig2{
       
   }
   

2. 在之前的配置类中选择导入这个配置类

   @Configuration
   @Import(MyConfig2.class)  //导入合并其他配置类，类似于配置文件中的 inculde 标签
   public class MyConfig {
   
      @Bean
      public Dog dog(){
          return new Dog();
     }
   
   }
   

   关于这种Java类的配置方式，我们在之后的SpringBoot 和 SpringCloud中还会大量看到，我们需要知道这些注解的作用即可！

静态/动态代理模式

为什么学习代理模式：

AOP的底层机制就是动态代理

代理模式：

• 静态代理
• 动态代理

静态代理：

静态代理角色分析

• 抽象角色：一般使用接口或者抽象类来实现
• 真实角色：被代理的角色
• 代理角色：代理真实角色；代理真实角色后，一般会做一些附属的操作
• 客户：使用代理角色来进行一些操作

代码实现

Rent . java 即抽象角色

//抽象对象：租房
public interface Rent {
   public void rent();
}

Host . java 即真实角色

//真实角色: 房东，房东要出租房子
public class Host implements Rent{
   public void rent() {
       System.out.println("房屋出租");
  }
}

Proxy . java 即代理角色

//代理角色：中介
public class Proxy implements Rent {

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

   //租房
   public void rent(){
       seeHouse();
       host.rent();
       fare();
  }
   //看房
   public void seeHouse(){
       System.out.println("带房客看房");
  }
   //收中介费
   public void fare(){
       System.out.println("收中介费");
  }
}

Client . java 即客户

//客户类，一般客户都会去找代理！
public class Client {
   public static void main(String[] args) {
       //房东要租房
       Host host = new Host();
       //中介帮助房东
       Proxy proxy = new Proxy(host);

       //你去找中介！
       proxy.rent();
  }
}

静态代理的好处：

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

缺点：

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

静态代理练习：

1. 创建一个抽象角色，平时做的业务就是增删改查

   //抽象角色增删改查业务
   public interface UserService {
      void add();
      void delete();
      void update();
      void query();
   }
   

2. 我们需要一个真实对象来完成这些增删改查操作

   //真实对象，完成增删改查操作的人
   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("查询了一个用户");
     }
   }
   

3. 需求来了，现在我们需要增加一个日志功能，怎么实现

• 思路1 ：在实现类上增加代码 【麻烦！】
• 思路2：使用代理来做，能够不改变原来的业务情况下，实现此功能就是最好的了

4. 设置一个代理类来处理日志！代理角色

   //代理角色，在这里面增加日志的实现
   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("执行了"+msg+"方法");
     }
   
   }
   

5. 测试访问类

   public class Client {
      public static void main(String[] args) {
          //真实业务
          UserServiceImpl userService = new UserServiceImpl();
          //代理类
          UserServiceProxy proxy = new UserServiceProxy();
          //使用代理类实现日志功能！
          proxy.setUserService(userService);
   
          proxy.add();
     }
   }
   

   我们在不改变原来的代码的情况下，实现了对原有功能的增强，这是AOP中最核心的思想

AOP:纵向开发，横向开发

动态代理

• 动态代理的角色和静态代理的一样 .

• 动态代理的代理类是动态生成的 . 静态代理的代理类是我们提前写好的

• 动态代理分为两类 : 一类是基于接口动态代理 , 一类是基于类的动态代理

• • 基于接口的动态代理----JDK动态代理
  • 基于类的动态代理--cglib
  • 现在用的比较多的是 javasist 来生成动态代理 . 百度一下javasist
  • 我们这里使用JDK的原生代码来实现，其余的道理都是一样的！

JDK的动态代理需要了解两个类

核心 : InvocationHandler 和 Proxy ， 打开JDK帮助文档看看

【InvocationHandler：调用处理程序】

Object invoke(Object proxy, 方法 method, Object[] args)；
//参数
//proxy - 调用该方法的代理实例
//method -所述方法对应于调用代理实例上的接口方法的实例。方法对象的声明类将是该方法声明的接口，它可以是代理类继承该方法的代理接口的超级接口。
//args -包含的方法调用传递代理实例的参数值的对象的阵列，或null如果接口方法没有参数。原始类型的参数包含在适当的原始包装器类的实例中，例如java.lang.Integer或java.lang.Boolean 。

【Proxy : 代理】

//生成代理类
public Object getProxy(){
   return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                                 rent.getClass().getInterfaces(),this);
}

代码实现：

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

//真实角色: 房东，房东要出租房子
public class Host implements Rent{
   public void rent() {
       System.out.println("房屋出租");
  }
}

ProxyInvocationHandler. java 即代理角色

public class ProxyInvocationHandler implements InvocationHandler {
   private Rent rent;

   public void setRent(Rent rent) {
       this.rent = rent;
  }

   //生成代理类，重点是第二个参数，获取要代理的抽象角色！之前都是一个角色，现在可以代理一类角色
   public Object getProxy(){
       return Proxy.newProxyInstance(this.getClass().getClassLoader(),
               rent.getClass().getInterfaces(),this);
  }

   // proxy : 代理类 method : 代理类的调用处理程序的方法对象.
   // 处理代理实例上的方法调用并返回结果
   @Override
   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
       seeHouse();
       //核心：本质利用反射实现！
       Object result = method.invoke(rent, args);
       fare();
       return result;
  }

   //看房
   public void seeHouse(){
       System.out.println("带房客看房");
  }
   //收中介费
   public void fare(){
       System.out.println("收中介费");
  }

}

//租客
public class Client {

   public static void main(String[] args) {
       //真实角色
       Host host = new Host();
       //代理实例的调用处理程序
       ProxyInvocationHandler pih = new ProxyInvocationHandler();
       pih.setRent(host); //将真实角色放置进去！
       Rent proxy = (Rent)pih.getProxy(); //动态生成对应的代理类！
       proxy.rent();
  }

}

核心：一个动态代理 , 一般代理某一类业务 , 一个动态代理可以代理多个类，代理的是接口！

我们也可以编写一个通用的动态代理实现的类！所有的代理对象设置为Object即可！

public class ProxyInvocationHandler implements InvocationHandler {
   private Object target;

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

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

   // proxy : 代理类
   // method : 代理类的调用处理程序的方法对象.
   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
       log(method.getName());
       Object result = method.invoke(target, args);
       return result;
  }

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

}

测试：

public class Test {
   public static void main(String[] args) {
       //真实对象
       UserServiceImpl userService = new UserServiceImpl();
       //代理对象的调用处理程序
       ProxyInvocationHandler pih = new ProxyInvocationHandler();
       pih.setTarget(userService); //设置要代理的对象
       UserService proxy = (UserService)pih.getProxy(); //动态生成代理类！
       proxy.delete();
  }
}

静态代理有的它都有，静态代理没有的，它也有！

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

AOP

AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。

Aop在Spring中的作用

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

以下名词需要了解下：

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