4.3 JavaEE-Spring和IOC

蔚落 2024-03-31 08:39 73阅读 0赞

**目录**

4.3.1 Spring概述

4.3.1.1 什么是Spring

4.3.1.2 Spring Framework

4.3.1.3 简单了解Spring

4.3.1.4 自定义Spring

4.3.2 Spring配置文件

4.3.2.1 IOC

4.3.2.2 Bean标签

4.3.2.2.1 Bean生命周期

4.3.2.2.2 Bean标签属性

4.3.2.2.3 Bean实例化三种方式

4.3.2.2.4 Bean注入依赖三种方式

4.3.2.2.5 不同类型Bean的注入依赖

4.3.2.3 Spring装配

4.3.2.3.1 什么是Spring装配

4.3.2.3.2 自动装配

4.3.2.3.3 自动装配模式

4.3.2.3.4 自动装配的局限

4.3.3 Spring配置数据源

4.3.3.1 之前手动配置连接池

4.3.3.1.1 C3P0

4.3.3.1.2 Druid

4.3.3.1.3 properties配置Druid

4.3.3.2 Spring配置C3P0、Druid数据源

4.3.3.2.1 步骤

4.3.3.2.2 坐标

4.3.3.2.3 c3p0

4.3.3.2.4 Druid

4.3.3.2.5 抽取jdbc配置文件

4.3.4 Spring注解开发

4.3.4.1 注解开发概述

4.3.4.2 @Component 、@Repository、@Service、@Controller 注解

4.3.4.2.1 概述

4.3.4.2.2 @Component

4.3.4.2.3 @Repository

4.3.4.2.4 @Service 注解

4.3.4.2.5 @Controller注解

4.3.4.3 Scope注解

4.3.4.4 PostConstruct、PreDestroy 注解

4.3.4.5 Value 注解

4.3.4.6 @Autowired、@Qualifier 注解

4.3.4.7 @Resource 注解

4.3.4.8 @Required注解

4.3.4.9 Spring配置类注解

4.3.4.9.1 Spring配置类概述

4.3.4.9.2 Configuration注解

4.3.4.9.3 ComponentScan注解

4.3.4.9.4 Import注解

4.3.4.9.5 PropertySource注解

4.3.4.9.6 value注解

4.3.4.9.7 bean注解

4.3.4.10 Spring的路径映射Mapping

4.3.4.10 RequestMapping

4.3.4.11 GetMapping

4.3.4.12 PostMapping

4.3.4.13 PutMapping

4.3.4.14 DeleteMapping

--------------------

## 4.3.1 Spring概述 ##

### 4.3.1.1 什么是Spring ###

Spring框架是轻量级的JavaEE框架。

可以整合很多第三方框架和类库目前是最主流的的Java EE 企业应用开源框架。

Spring有两个核心部分：**IOC**和**Aop**

（1）IOC：控制反转，把创建对象的过程交给Spring进行管理

（2）Aop：面向切面，不修改源代码进行功能增强

Spring特点：

1.  方便解耦，简化开发
2.  Aop变成支持
3.  方便程序测试
4.  方便和其他框架进行整合
5.  方便进行事物操作
6.  降低API开发难度

### 4.3.1.2 Spring Framework ###

Spring官网将整个Spring框架分成：

### 4.3.1.3 简单了解Spring ###

**1.导入Spring坐标**

<dependencies>
          <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.5.RELEASE</version>
          </dependency>
      </dependencies>

>

**2.书写StudentService接口、StudentServiceImpl接口实现类**

public interface StudentService {
        public void hello();
    }
    
    
    
    public class StudentServiceImpl implements StudentService {
        @Override
        public void hello() {
            System.out.println("hello Spring");
        }
    }

**3.创建Spring核心配置文件**

**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"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
       </beans>

**4.在 Spring 配置文件中配置 StudentServiceImpl**

**5.测试类**

public class SpringTest {
        @Test
        public void test(){
            ApplicationContext applicationContext = new
                    ClassPathXmlApplicationContext("applicationContext.xml");
            StudentService studentService = (StudentService) applicationContext.getBean("studentService");
            studentService.hello();
        }
    }

![7bc76e235c8d42a38cdb6695e1914b13.png][]**运行结果**

经过上面的尝试，我们发现先，在测试方法中，我们没有创建**StudentService**或**StudentServiceImpl**,但是却直接调用了方法。这就是Spring的工厂模式，简单来说，Spring替我们newl，我们直接拿来用即可。

简单说明一下上述测试代码中用到的Spring API。

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>ApplicationContext</td> 
   <td>接口类型，可以通过其实例获得 Spring 容器中的 Bean 对象</td> 
  </tr> 
  <tr> 
   <td>ClassPathXmlApplicationContext</td> 
   <td>类的根路径下加载配置文件</td> 
  </tr> 
  <tr> 
   <td>getBean</td> 
   <td>获取实例对象</td> 
  </tr> 
 </tbody> 
</table>

### 4.3.1.4 自定义Spring ###

## 4.3.2 Spring配置文件 ##

### 4.3.2.1 IOC ###

IOC:Inversion of Control ,控制反转。是一种设计思想，将对象交给容器控制，而非对象内部直接new。传统的应用程序使我们在类的内部显式的创建依赖的对象。从而导致类于类之间耦合度过高。而IOC思想是将对象的创建，查找依赖，以及生命周期的控制权交给了IOC容器。对象之间耦合较松，更加灵活。

实现IOC具体采用的方法就是：注入依赖（Dependency Injection ,DI）。

依赖注入：就是为当前类中的属性赋值的过程。

**IOC优点**

1.  它将最小化应用程序中的代码量。
2.  它将使您的应用程序易于测试，因为它不需要单元测试用例中的任何单例 或 JNDI 查找机制。
3.  它以最小的影响和最少的侵入机制促进松耦合。
4.  它支持即时的实例化和延迟加载服务。

### 4.3.2.2 Bean标签 ###

Bean用来默认调用类的无参构造方法来创建对象

#### 4.3.2.2.1 Bean生命周期 ####

详细讲解【[4.7 深入理解Spring\_老李头喽的博客-CSDN博客][4.7 _Spring_-CSDN]】

![b2763fb071664188b0db314c555c4caa.png][]

#### 4.3.2.2.2 Bean标签属性 ####

<table style="width:615px;"> 
 <tbody> 
  <tr> 
   <td colspan="2" style="width:175px;">id</td> 
   <td style="width:437px;">Bean实例唯一标识</td> 
  </tr> 
  <tr> 
   <td colspan="2" style="width:175px;">class</td> 
   <td style="width:437px;">Bean的全限定名</td> 
  </tr> 
  <tr> 
   <td colspan="1">scope</td> 
   <td style="width:58px;">取值</td> 
   <td style="width:437px;">singleton ：单例、默认值</td> 
  </tr> 
  <tr> 
   <td style="width:437px;">prototype ：多例</td> 
  </tr> 
  <tr> 
   <td style="width:437px;">request ：WEB 项目中，Spring 创建一个 Bean 的对象，将对象存入到 request 域中</td> 
  </tr> 
  <tr> 
   <td style="width:437px;">session ：WEB 项目中，Spring 创建一个 Bean 的对象，将对象存入到 session 域中</td> 
  </tr> 
  <tr> 
   <td style="width:437px;">global session ：WEB 项目中，应用在 Portlet 环境，如果没有 Portlet 环境那么globalSession 相当于 session</td> 
  </tr> 
 </tbody> 
</table>

#### 4.3.2.2.3 Bean实例化三种方式 ####

1.  无参构造方法
2.  工厂静态方法
3.  工厂实例方法

**1、无参构造方法获取实例对象**

根据类的无参构造方法来创建类对象，如果没有无参构造方法，会创建失败 。

**User类**

@Data
    @NoArgsConstructor
    @AllArgsConstructor
    public class User {
        private String name;
        private int age;
        private String sex;
        private String addr;
    }

**applicationContext.xml**

**测试**

@Test
        public void test() {
            ClassPathXmlApplicationContext cpxa = new ClassPathXmlApplicationContext("applicationContext.xml");
            User u1 = (User) cpxa.getBean("u1");
            System.out.println(u1);
            
        }

![8eb467b7a48a4811b96cb01ecffe5d57.png][]

**2、工厂静态方法获取实例对象**

**静态工厂类**

public class StaticFactoryBean {
        //通过静态方法获取对象
        public static User create(){
            return  new User();
        }

**3、工厂实例方法获取实例对象**

先创建工厂对象，然后再调用方法获取对象。

public class DynamicFactoryBean {
        //调用此方法需要先创建工厂对象 之后通过方法创建指定对象
        public User create(){
            return  new User();
        }
    }

#### 4.3.2.2.4 Bean注入依赖三种方式 ####

1.  构造方法注入
2.  set方法注入
3.  注解注入

**1、构造方法注入**  
必须定义有参数，与对应形参数量相同，的构造方法  
一般构造方法重写按照参数个数 所以还可以通过索引类型赋值

直接赋值的方式
    
            <bean id="d1" class="com.bl.javabean.User">
                <constructor-arg name="username" value="张三"/>
                <constructor-arg name="age" value="18"/>
            </bean>
            
            <bean id="d2" class="com.bl.javabean.User">
                <constructor-arg index="0" value="1" type="int" ></constructor-arg>
                <constructor-arg index="1" value="张三" type="java.lang.String" ></constructor-arg>
                <constructor-arg index="2" value="1234567"  ></constructor-arg>
                <constructor-arg index="3" value="138456584534543"  ></constructor-arg>
            </bean>
    传入对象
        
        <bean id="userDao" class="com.bl.dao.impl.UserDaoImpl"/>
        <bean id="userService" class="com.bl.service.impl.UserServiceImpl">      		   	            <constructor-arg name="userDao" ref="userDao"></constructor-arg>
    </bean>

**2、set方法注入**  
自动为指定属性调用set方法进行赋值

**3、注解注入**

后面的《4.3.4.6 Autowired、Qualifier 注解》会详细讲解。

#### 4.3.2.2.5 不同类型Bean的注入依赖 ####

普通数据类型 引用数据类型 集合数据类型

自定义类型

@Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class Teacher implements Serializable {
        private int tid;
        private String tname;
    }

@Data
    @AllArgsConstructor
    public class Student {
        private int sid;
        private String sname;
        private Teacher t;

引用类型注入  
      <bean id="tea" class="com.yunhe.javabean.Role">
            <property name="tid" value="1"></property>
            <property name="tname" value="孙老师"></property>
        </bean>    
    
    
    <bean id="s_t" class="com.ybl.javabean.Student">
            <property name="sid" value="1"></property>
            <property name="sname" value="张三"></property>
            
            <property name="t" ref="tea"></property>
        </bean>

**list集合类型**

list集合注入：**基本类型**的list集合注入、**自定义类型**的list集合注入。

**1、**基本类型的list集合注入

@Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class Teacher {
        private String name;
        private List<String> students;
    }

**2、**自定义类型的list集合注入

@Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class Teacher {
        private String name;
        private List<User> students;
    }

使用ref标签替代value标签
    
        <bean id="list" class="com.bl.javabean.Teacher">
            <property name="name" value="孙老师"></property>
            <property name="teachers">
                <list>
                    1.可以直接使用已经交由spring容器管理的对象
                    <ref bean="user对象1"></ref>
                    <ref bean="user对象2"></ref>
                    2.也可以直接创建新的对象使用 直接创建bean标签书写
                    <bean class="com.bl.javabean.User">
                        <property name="username" value="小李同学"></property>
                    </bean>
                </list>
            </property>
        </bean>

**map集合类型**

<bean id="list3" class="com.bl.javabean.Teacher">
            <property name="name" value="孙老师"></property>
            <property name="map">
                <map>
                    
                    <entry key="a" value-ref="u1"></entry>
                    <entry key="b" value-ref="u2"></entry>
                </map>
            </property>
        </bean>

**properties集合类型**

<bean id="list4" class="com.bl.javabean.Teacher">
            <property name="p">
                
                <props>
                    <prop key="a1">a</prop>
                    <prop key="b1">b</prop>
                </props>
            </property>
        </bean>

**数组类型**

### 4.3.2.3 Spring装配 ###

#### 4.3.2.3.1 什么是Spring装配 ####

Bean与Bean之间建立依赖关系，称为装配

很多bean 在 Spring 容器中组合在一起时，被称为装配或 bean 装配

#### 4.3.2.3.2 自动装配 ####

自动装配，其实和依赖注入是一样的，只不过我们进行依赖注入的时候，需要在XML配置文件里面，通过<property>标签或者<constructor-arg>标签，手动的进行属性赋值。

为了能够简化一下依赖注入，就出现了自动装配

Spring自动给属性赋值，从而简化XML配置

#### 4.3.2.3.3 自动装配模式 ####

Spring中默认情况下，是没有开启自动装配的功能，如果我们需要使用自动装配，则需要通过在<bean>标签中添加 autowire属性，然后设置采用哪种自动装配的方式，Spring提供了五种自动装配的方式，分别是：

no：表示不自动装配。

default：表示按照【<beans>】根标签上面配置的【default-autowire】方式进行自动装配。

byType：表示根据Bean的数据类型进行自动装配。（如果存在多个相同数据类型的Bean，则自动装配失败，抛出异常。）

byName：表示根据Bean的名称进行自动装配。（根据bean的id属性值进行属性，如果存在多个相同名称的id属性值，则抛出异常。）

constructor：表示通过构造方法进行自动装配。（根据Bean的构造方法进行自动装配，根据构造方法参数的数据类型进行属性赋值。）

#### 4.3.2.3.4 自动装配的局限 ####

会有覆盖的可能性

您始终可以使用和设置指定依赖项，这将覆盖自动装配。基本元数据类型 - 简单属性（如原数据类型， 字符串和类）无法自动装配。令人困惑的性质 - 总是喜欢使用明确的装配，因为自动装配不太精确。

## 4.3.3 Spring配置数据源 ##

### 4.3.3.1 之前手动配置连接池 ###

#### 4.3.3.1.1 C3P0 ####

**C3P0**

//创建数据源
            ComboPooledDataSource dataSource = new ComboPooledDataSource();
            //设置数据库连接参数
            dataSource.setDriverClass("com.mysql.jdbc.Driver");
            dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test");
            dataSource.setUser("root");
            dataSource.setPassword("root");
            //获得连接对象
            Connection connection = dataSource.getConnection();
            System.out.println(connection);

#### 4.3.3.1.2 Druid ####

**Druid**

//创建数据源
        DruidDataSource dataSource = new DruidDataSource();
        //设置数据库连接参数
        dataSource.setDriverClassName("com.mysql.jdbc.Driver"); 
        dataSource.setUrl("jdbc:mysql://localhost:3306/test");   
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        //获得连接对象
        Connection connection = dataSource.getConnection();    
        System.out.println(connection);

#### 4.3.3.1.3 properties配置Druid ####

**jdbc.properties**

jdbc.driver=com.mysql.jdbc.Driver
    jdbc.url=jdbc:mysql://localhost:3306/test
    jdbc.username=root
    jdbc.password=root

//加载类路径下的jdbc.properties
        ResourceBundle rb = ResourceBundle.getBundle("jdbc");
        ComboPooledDataSource dataSource = new ComboPooledDataSource(); 
        dataSource.setDriverClass(rb.getString("jdbc.driver"));   
        dataSource.setJdbcUrl(rb.getString("jdbc.url")); 
        dataSource.setUser(rb.getString("jdbc.username")); 
        dataSource.setPassword(rb.getString("jdbc.password"));
        Connection connection = dataSource.getConnection();   
        System.out.println(connection);

### 4.3.3.2 Spring配置C3P0、Druid数据源 ###

现在可以将DataSource交由Spring容器去创建。

DataSource有无参构造方法，而Spring默认就是通过无参构造方法实例化对象的

DataSource要想使用需要通过set方法设置数据库连接信息，而Spring可以通过set方法进行字符串注入

#### 4.3.3.2.1 步骤 ####

1.  导入数据源的坐标和数据库驱动坐标
2.  创建数据源对象
3.  设置数据源的基本连接数据
4.  使用数据源获取连接资源和归还连接资源

#### 4.3.3.2.2 坐标 ####

**Spring坐标**

> <dependency>  
> <groupId>org.springframework</groupId>  
> <artifactId>spring-context</artifactId>  
> <version>5.1.2.RELEASE</version>  
> </dependency>

**mysql坐标**

> <dependency>  
> <groupId>mysql</groupId>  
> <artifactId>mysql-connector-java</artifactId>  
> <version>5.1.39</version>  
> </dependency>

**c3p0坐标**

> <dependency>  
> <groupId>c3p0</groupId>  
> <artifactId>c3p0</artifactId>  
> <version>0.9.1.2</version>  
> </dependency>

**Druid坐标**

> <dependency>  
> <groupId>com.alibaba</groupId>  
> <artifactId>druid</artifactId>  
> <version>1.1.10</version>  
> </dependency>

#### 4.3.3.2.3 c3p0 ####

**c3p0.xml**

<bean id="c3p0" class="com.mchange.v2.c3p0.ComboPooledDataSource">
            
            <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
            <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/mydb"></property>
            <property name="user" value="root"></property>
            <property name="password" value="123456"></property>
        </bean>

**测试类**

public class MyC3P0 {
        static ClassPathXmlApplicationContext cpac=null;
        //加载spring核心配置文件创建spring容器对象
        static{
            cpac =new ClassPathXmlApplicationContext("c3p0.xml");
        }
       @Test
        public void c3p0() throws SQLException {
            //DataSource是java提供的数据源接口
            //所有的连接池必须实现该接口 所以在开发中
            //通过声明DataSource数据源对象 保存对应的连接池是数据源对象
            DataSource ds = (DataSource) cpac.getBean("c3p0");
            Connection connection = ds.getConnection();
            System.out.println(connection);
        }
    }

#### 4.3.3.2.4 Druid ####

**applicationContext.xml**

**测试**

@Test
        public void druid() throws Exception {
           DataSource dataSource= (DataSource) cpac.getBean("druid");
            Connection connection = dataSource.getConnection();
            System.out.println(connection);
        }

#### 4.3.3.2.5 抽取jdbc配置文件 ####

我们修改 4.3.3.2.4 Druid中代码。applicationContext.xml加载jdbc.properties配置文件获得连接信息。

首先，需要引入context命名空间和约束路径：

之后才能使用context:property-placeholder标签加载properties配置文件

> <**context:property-placeholder** location="classpath:jdbc.properties"/>

**jdbc.properties**

jdbc.driver=com.mysql.jdbc.Driver
    jdbc.url=jdbc:mysql://localhost:3306/mydb
    jdbc.username=root
    jdbc.password=123456

**applicationContext.xml**

**测试类**

public class MyDruid {
        static ClassPathXmlApplicationContext cpac=null;
        //加载spring核心配置文件创建spring容器对象
        static{
            cpac =new ClassPathXmlApplicationContext("druid.xml");
        }
        @Test
        public void druid() throws SQLException {
            DruidDataSource dataSource=new DruidDataSource();
            dataSource.setDriverClassName("com.mysql.jdbc.Driver");
            dataSource.setUrl("jdbc:mysql://localhost:3306/mydb");
            dataSource.setUsername("root");
            dataSource.setPassword("123456");
    
            DruidPooledConnection connection = dataSource.getConnection();
            System.out.println(connection);
        }

## 4.3.4 Spring注解开发 ##

### 4.3.4.1 注解开发概述 ###

**注解方便，但是注解不是万能的，自己定义的类可以使用注解，但是如果类不是自己定义的呢？c3p0、druid你怎么注解？**

在实际开发过程中一般都会使用注解开发来简化配置。

需要额外引入context头文件以及约束文件

spring注解开发很简单 只需要在引入头文件和约束后 书写标签开启注解扫描即可  
将需要使用注解开发的包进行配置，spring容器在创建时会自动扫描指定的包以及包下的书写注解的类并进行配置。

> <context:component-scan base-package="包名"/>
> 
> 指定包下使用注解开发
> 
> 通常用具体包名

在实例bean对象时，我们一般用注解来代替无参构造方法，而工厂静态方法和工厂实例方法还用配置文件的形式。也就是说，我们自己写的类可以用注解，不是我们写的类，不用注解。

### 4.3.4.2 **@Component** 、**@Repository、@Service、@Controller** 注解 ###

#### 4.3.4.2.1 概述 ####

**@Component ：在类上用于实例化Bean**

**@Repository ：在dao层类上用于实例化Bean**

**@Service ：在service层类上用于实例化Bean**

**@Controller ：在web层类上用于实例化Bean**

四个注解功能相同，为了之后区分spring管理对象的功能,所以定义了功能相同名称却不同的注解，用于配置对象。

等价于在spring核心配置文件中书写bean标签 。

**格式**

> @Component  
> @Controller  
> @Service  
> @Repository
> 
> public class 类\{  
> \}
> 
> 如果不指定，spring扫描后会直接创建指定对象, id就是类名首字母小写。
> 
> @Service id就是student
> 
> public class Student\{  
> \}
> 
> @Service("stu") id就是stu
> 
> public class Student\{  
> \}

**示例**

**User类**

@Data
    @NoArgsConstructor
    @AllArgsConstructor
    @Component
    public class User {
        private int uid;
        private String uname;
        private Role r;

**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: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">
        
        开启后可以使用注解进行配置 @Component(id) id可以省略 如果省略默认使用类名首字母小写创建
        <context:component-scan base-package="com"/>
    
    </beans>

**测试类**

public class mytest {
        static ClassPathXmlApplicationContext cpac = null;
    
        //加载spring核心配置文件创建spring容器对象
        static {
            cpac = new ClassPathXmlApplicationContext("applicationContext.xml");
        }
    
        @Test
        public void test() {
            User u1 = (User) cpac.getBean("user");
            System.out.println(u1);
    
        }
    
    
    }

#### 4.3.4.2.2 **@Component** ####

而@Component泛指各种组件，就是说当我们的类不属于各种归类的时候（不属于@Controller、@Services等的时候），我们就可以使用@Component来标注这个类。

@Component
    public class UserDaoImpl implements UserDao {
        @Override
        public void selectAll() {
            System.out.println("userDao.selectAll()执行");
        }
    }

@Test
        public void Dao(){
           UserDao userDao= (UserDao) cpac.getBean("userDaoImpl");
           userDao.selectAll();
        }

#### 4.3.4.2.3 **@**Repository ####

@Repository与Component功能一样，用于在Dao实现层创建DaoImpl实现类。

将4.3.4.2.2 中的代码修改为以下，会发现运行结果与上面一致。

//@Component
    @Repository
    public class UserDaoImpl implements UserDao {
        @Override
        public void selectAll() {
            System.out.println("userDao.selectAll()执行");
        }
    }

@Test
        public void Dao(){
           UserDao userDao= (UserDao) cpac.getBean("userDaoImpl");
           userDao.selectAll();
        }

#### 4.3.4.2.4 @Service 注解 ####

用在service层类上创建serviceImpl实现类。

@Service
    public class UserServiceImpl implements UserService {
        UserDao userDao=new UserDaoImpl();
        @Override
        public List<User> findAll() {
            System.out.println("UserServiceImpl执行");
            userDao.selectAll();
            return null;
        }
    }

#### 4.3.4.2.5 @Controller注解 ####

用在web层类上创建Controller实现类。

@Controller
    public class UserController {
        UserService userService=new UserServiceImpl();
        
        public void all(){
            userService.findAll();
        }
    }

### 4.3.4.3 Scope注解 ###

用于标识当前由spring管理的类的作用域，分为单例和多例，默认（不书写）为单例。

@Scope("prototype")//多例
    @Scope("singleton")//单例
    public class 类{
    }

### 4.3.4.4 PostConstruct、PreDestroy 注解 ###

用于在标识由spring管理的类中的初始化与销毁方法

**user类**

@Data
    @NoArgsConstructor
    @AllArgsConstructor
    @Component
    @Scope
    public class User {
        private int id;
        private String name;
    
     // 等价于bean标签中的init-method
        @PostConstruct
        public void init() {
            System.out.println("初始化");
    
        }
    //等价于bean标签中的destroy-method
        @PreDestroy 
        public void destroy() {
            System.out.println("销毁");
        }
    
    }

**测试类**

![3c9234afc31b42f3a071bfbd43b6aff4.png][]

### 4.3.4.5 Value 注解 ###

用于对spring创建的对象基本属性值进行属性赋值注入

注入依赖说白了就是**赋值**

public class User {
         @Value("1")
        private int id;
        @Value("张三")
        private String name;
        @Value("18")
        private int age;
        @Value("男")
        private String sex;
    
    }

### 4.3.4.6 @Autowired、@Qualifier 注解 ###

思考前面《4.3.2.2.4 Bean注入依赖三种方式》，其中有注解注入方式

由于定义在接口，也可将”注解注入“称之为”接口注入“。

> **@Autowired：**自动注入 根据类型进行注入。与@Qualifier搭配使用
> 
> **@Qualifier(" ")：**根据指定的id进行注入。
> 
>   
> 流程：先根据类型进行自动注入 ，若无匹配类型 ，则根据名称进行自动注入。  
>

@Service("userService")//将当前类交由spring容器管理
    public class UserServiceImpl implements UserService {
        //以前的方法是先new UserDaoImpl获得UserDao实现类，现在用注解方式，而且UserDaoImpl已经交由spring容器管理
        //private UserDao userdao=new UserDaoImpl();
        @Autowired
        @Qualifier("userDao")
        //执行流程 先从spring容器中查找UserDao类型的对象 如果没有找到 就查找指定id的数据存入对象
        private UserDao userDao;
    
        @Override
        public void findAll() {
            userDao.selectAll();
        }
    }

**测试类**

@Test
        public void userService(){
            UserService userService = (UserService) cpac.getBean("userService");
            userService.findAll();
        }

### 4.3.4.7 @Resource 注解 ###

功能和@Autowired、@Qualifier 注解一样，推荐使用@Resource注解

由于定义在接口，也可将”注解注入“称之为”接口注入“。

只不过@Resource 注解，先按变量名进行匹配（将变量名当前id），若无再按类型匹配

> 注意
> 
> **import javax.annotation.Resource;**
> 
> **@Resource不是由Spring提供，而是由JAVA提供**

public class UserController {
    
        //private UserService userService=new UserServiceImpl();
        @Resource
        //也是自动注入的注解
        //只不过不是由spring提供的 而是java提供的注解在spring中使用
        //先按变量名进行匹配（将变量名当前id） 如果没有再按类型匹配
        private UserService userService;
        public void find(){
            System.out.println("userControoler执行 查询数据");
            userService.findAll();
        }
    }

### 4.3.4.8 @Required注解 ###

@Required 注解主要用在 setter 方法上

表示该 setter 方法的属性必须要在配置时注入值。否则就会报 BeanInitializationException 异常

如

**student类**

public class Student {
    	private String name;
    	private Integer age;
        //定义了两个被required修饰的set方法
    	@Required
    	public void setAge(Integer age) {
    		this.age = age;
    	}
        
    	@Required
    	public void setName(String name) {
    		this.name = name;
    	}
    }

**配置文件**

<bean id="student" class="com.demo.Student">
    
    		<property name="name" value="gmk"></property>
    	</bean>

**运行结果**

![9a1c299c89bf46238506592cfe7f0ca1.png][]

如果在配置文件中把age的值也配置好，就可正常

### 4.3.4.9 Spring配置类注解 ###

#### 4.3.4.9.1 Spring配置类概述 ####

定义一个配置类替代原有的xml配置文件。**需要使用专门读取注解配置类的方式进行读取初始化spring容器** 。

@Configuration 指定当前类为 Spring 配置类，创建容器时会从该类上加载注解

@ComponentScan 指定 Spring 在初始化容器时要扫描的包。 作用和 Spring 的 xml 配置文件中的 <context:component-scan base-package="com.bl"/>一样

@Bean 标注将方法的返回值存储到 Spring 容器中

@PropertySource 加载.properties 文件中的配置

@Import 导入其他配置类

#### 4.3.4.9.2 Configuration注解 ####

标注当前类为spring核心配置类，相当于创建spring.xml并引入头文件

@Configuration
    public class SpringConfiguration {
        
    }

读取配置类方法

public class Test {
        public static void main(String[] args) throws Exception {
            ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfiguration.class);
            Object o= applicationContext.getBean("");
           
        }
    }

#### 4.3.4.9.3 ComponentScan注解 ####

相当于spring核心配置文件中,配置包的扫描 <context:component-scan base-package=“com.bl”/>

//同于标注当前类为spring核心配置类
    @Configuration
    //用于标识扫描进行管理的类所在的包
    @ComponentScan("com.bl")
    public class SpringConfiguration {
    
    }

#### 4.3.4.9.4 Import注解 ####

导入其他配置类

//同于标注当前类为spring核心配置类
    @Configuration
    //用于标识扫描进行管理的类所在的包
    @ComponentScan("com.bl")
    //用于导入其他类的管理多个类使用,分隔
    @Import({DSpringConfiguration2.class})
    public class SpringConfiguration {
    
    }

#### 4.3.4.9.5 PropertySource注解 ####

加载propertie配置文件 ，相当于 <context:property-placeholder location="classpath:jdbc.properties"/>

@PropertySource("classpath:jdbc.properties")
    public class SpringConfiguration {
    
    }

classpath表示当前路径，可忽略不写，表示的target下的classes路径 下的内容。

![a09eef69681d4b778046c4c55075606a.png][] classpath

#### 4.3.4.9.6 value注解 ####

用于属性的注入 (赋值)，用法分两种：常规属性值注入，抽取配置文件属性值注入

**常规属性值注入**

public class DataSourceConfiguration {
        @Value("com.mysql.jdbc.Driver")
        private String driver;
        @Value("jdbc:mysql://localhost:3306/mydb")
        private String url;
        @Value("root")
        private String username;
        @Value("123456")
        private String password;
    }

**抽取配置文件属性值注入**

**jdbc.properties**

jdbc.driver=com.mysql.jdbc.Driver
    jdbc.url=jdbc:mysql://localhost:3306/mydb
    jdbc.username=root
    jdbc.password=123456

@PropertySource("classpath:jdbc.properties")
    public class DataSourceConfiguration {
        @Value("${jdbc.driver}")
        private String driver;
        @Value("${jdbc.url}")
        private String url;
        @Value("${jdbc.username}")
        private String username;
        @Value("${jdbc.password}")
        private String password;
    }

#### 4.3.4.9.7 bean注解 ####

配置spring管理的对象 ，相当于 <bean id="" class=" ">通过工厂方法获取

### 4.3.4.10 Spring的路径映射Mapping ###

#### 4.3.4.10 RequestMapping ####

略

Spring4.3中引进了@GetMapping、@PostMapping、@PutMapping、@DeleteMapping来帮助简化常用的HTTP方法的映射 并更好地表达被注解方法的语义

#### 4.3.4.11 GetMapping ####

1.根据前端的提交方式确定映射类型

# 示例
    <form action="testGetMapping" method="get">这里使用@GetMapping<form/>

2.@GetMapping就是一个只能用来处理http的get请求的注解，经常用于**查询**

3.无参，@RequestParam和@PathVaiable的情况下使用GetMapping

#### 4.3.4.12 PostMapping ####

1.根据前端

<form action="testPostMapping" method="post">这里使用@PostMapping<form/>

2.如果传的参数是@RequestBody ，多参或者传对象的情况下使用@PostMapping注解

@PostMapping("/getOrderList")
    public List<Object> getList(@RequestBody List<Object> orderList) {}

3.通常用来处理post请求，常用于执行**添加操作**

#### 4.3.4.13 PutMapping ####

和@PostMapping类似

通常用来处理put请求，常用于执行**更新操作**

#### 4.3.4.14 DeleteMapping ####

[7bc76e235c8d42a38cdb6695e1914b13.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/f228e48e78b74bc3afa63d51444484ac.png
[4.7 _Spring_-CSDN]: https://blog.csdn.net/qq_43757965/article/details/128066080?spm=1001.2014.3001.5501
[b2763fb071664188b0db314c555c4caa.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/ea3457202c744d3eb5204e5535ec46c5.png
[8eb467b7a48a4811b96cb01ecffe5d57.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/8d7f9d53625f40b4a51a121d8906b7e0.png
[3c9234afc31b42f3a071bfbd43b6aff4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/933346c2c77f48a58864521530f471dc.png
[9a1c299c89bf46238506592cfe7f0ca1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/faf4a88e03d74e079aece729963996c1.png
[a09eef69681d4b778046c4c55075606a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/24ae8a078d3a408f8a218577725e92ec.png