# Spring-study

**Repository Path**: amespaces/Spring-study

## Basic Information

- **Project Name**: Spring-study
- **Description**: 学习回顾Spring
- **Primary Language**: Java
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2022-03-22
- **Last Updated**: 2022-07-04

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

ioc容器

- ioc(Inversion of Control)控制反转
  - ==使用对象时，由主动new产生对象转换为外部提供对象，此过程中对象的控制权由程序转移到外部==
- Spring技术对Ioc的实现
  - ioc容器用来充当外部
  - ioc容器负责对象的创建，初始化等一系列的工作，被创建或被管理的对象在Ioc容器中被统称Bean
- DI(Dependency Injection)依赖注入
  - 在容器中建立Bean与Bean之间的依赖关系的整个过程（如service 与 dao）

## Bean的作用范围

- 适合交给容器进行管理的bean
  - 表现层对象
  - 业务层对象
  - 数据层对象
  - 工具对象
- 不适合交给容器进行管理的对象
  - 封装实体的域对象

## 实例化bean

- **使用可访问的构造方法(常用）**
  
  - 无参构造方法如果不存在，抛出异常BeanCreateionException
  
    ```xml
    <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"></bean>
    ```
  
- **使用静态工厂实例化**

  ```xml
  <bean id="orderDao" class="com.itheima.factory.OrderDaoFactory" factory-method="getOrderDao"/>
  ```

  ```java
  import com.itheima.dao.OrderDao;
  import com.itheima.dao.impl.OrderDaoImpl;
  
  public class OrderDaoFactory {
      public static OrderDao getOrderDao(){
          return new OrderDaoImpl();
      }
  
  }
  
  ```

- **使用实例化工厂实例化bean**

  ```xml
  <bean id="userFactory" class="com.itheima.factory.UserDaoFactory"/>
  <bean id="userDao" factory-bean="userFactory" factory-method="getUserDao"/>
  ```

  ```java
  import com.itheima.dao.UserDao;
  import com.itheima.dao.impl.UserDapImpl;
  
  public class UserDaoFactory {
      public UserDao getUserDao(){
          return new UserDapImpl();
      }
  }
  
  ```

- 使用factoryBean实例化Bean

  ```xml
  <bean id="userDao" class="com.itheima.factory.UserDaoFactoryBean"/>
  ```

  ```java
  import com.itheima.dao.UserDao;
  import com.itheima.dao.impl.UserDapImpl;
  import org.springframework.beans.factory.FactoryBean;
  
  public class UserDaoFactoryBean implements FactoryBean<UserDao> {
  //代替原始实例工厂中创建对象的方法
      public UserDao getObject() throws Exception {
          return new UserDapImpl();
      }
      public Class<?> getObjectType() {
          return UserDao.class;
      }
       public boolean isSingleton() {
          return true;
      }
  }
  ```

## 配置生命周期

- 提供生命周期的方法，配置生命周期

  ```xml
  <bean id= "bookDao" class="com.itheima.dao.impl.BookDaoImpl" init-method="init" destory-method="destory"
  ```

- 使用接口，实现InitializingBean,DisposableBean接口

- bean生命周期

  - 初始化容器
    1. 创建对象(内存分配)
    2. 执行构造方法
    3. 执行属性注入set操作 
    4. 执行bean初始化方法
  - 使用bean
  - 关闭、销毁容器
    1. 执行Bean的销毁方法

## 依赖注入方式

- setter注入

  - 简单类型

  - 引用类型

    ```xml
    
        <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
            <property name="dataBaseName" value="mysql"/>
            <property name="connectionNum" value="2"/>
        </bean>
        <bean id="userDao" class="com.itheima.dao.impl.UserDapImpl"/>
        <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
            <property name="bookDao" ref="bookDao"/>
            <property name="userDao" ref="userDao"/>
        </bean>
    ```

    

- 构造器注入

  - 简单类型

  - 引用类型

    ```xml
    <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
            <constructor-arg name="dataBaseName" value="mysql"/>
            <constructor-arg name="connectionNum" value="90"/>
        </bean>
        <bean id="userDao" class="com.itheima.dao.impl.UserDapImpl"/>
    
        <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
          <constructor-arg name="bookDao" ref="bookDao"/>
            <constructor-arg name="userDao" ref="userDao"/>
         </bean>
    
    ```

## 依赖自动装配

- Ioc容器根据Bean所依赖的资源在容器中自动查找并注入到bean中的过程
- 自动装配的方式
  - 按类型(常用 )
  - 按名称
  - 按构造方法
  - 不启动自动装配 
- 依赖自动装配特征
  - 自动装配用于**引用类型**依赖注入，不能对简单类型进行操作
  - 使用按类型装配时byType必须保障容器中相同类型的bean唯一
  - 使用byName必须保障容器中具有指定名称的bean，因变量名与配置耦合,不推荐使用
  - 自动装配优先级低于setter注入与构造器注入，同时出现会失效

## 加载properties文件

1. 开启context的命名空间

2. 使用context空间加载properties

   ```xml
   //<context:property-placehoder location="jdbc.properties"/>
   <context:property-placeholder location="classpath:*.properties"/>
    <bean  class="com.alibaba.druid.pool.DruidDataSource">
           <property name="driverClassName" value="${jdbc.driver}"/>
           <property name="url" value="${jdbc.url}"/>
           <property name="username" value="${jdbc.username}"/>
           <property name="password" value="${jdbc.password}"/>
       </bean>
   ```

   jdbc.porperties

   ```
   jdbc.driver=com.mysql.jdbc.Driver
   jdbc.url=jdbc:mysql://127.0.0.1:3306/mybatis
   jdbc.username=root
   jdbc.password=root
   ```

   ```xml
   不加载系统属性
   <context:property-placeholder location="jdbc.properties" system-properties-mode="NEVER"/>
   加载多个properties文件
   <context:property-placeholder location="jdbc.properties,msgproperties/>
   加载所有的properties文件
   <context:property-placeholder location="*.properties/>
   加载properties文件的=标准模式=
   <context:property-placeholder location="classpath:*.properties/>
   从类路径或者jar包中搜索并加载properties文件
   <context:property-placeholder location="classpath*:*.properties/>                                     
   ```

   ## 容器

   1. 创建容器

      ```java
      //类路径加载配置文件
      ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
      //文件路径加载配置文件
       FileSystemXmlApplicationContext fileSystemXmlApplicationContext = new FileSystemXmlApplicationContext("D:\\IdeaProjects\\springstudy\\spring_10_container\\src\\main\\resources\\applicationContext.xml");
      //加载多个配置文件
      ApplicationContext context = ClassPathXmlApplicationContext("bean1.xml,bean2.xml");
      ```

   2. 获取bean

      ```
      //1.按bean名称获取
      BookDao bookDao = (BookDao) context.getBean("bookDao");
      //2.按bean名称获取并指定类型
      BookDao bookDao= context.getBean("bookDao",bookDao.class);
      //使用bean类型获取
      BookDao bookDao = context.getBean(BookDao.class)
      
      ```

   3. 容器类的层次结构

   4. BeanFactory是Ioc容器类的顶层接口,初始化BeanFactory对象时，加载的bean延迟加载

   5. 注意

      - ApplicationContext接口时Spring容器的核心接口，初始化时Bean立即加载

## 注解开发bean

- 使用@Component定义bean

  ```xml
  核心配置文件中通过组件扫描加载bean
  <context:component-scan base-package="com.itheima"/>
  ```

- Spring提供@Component注解的三个衍生注解

  - @Controller:用于表现层bean定义
  - @Service:用于业务层bean定义
  - @Repository用于数据层bean定义                                
  
###纯注解开发

- Spring3开启了纯注解开发的模式，使用java类代替配置文件，开启了Spring快速开发
- java类代替Spring核心配置文件

```java

@Configuration
//用于设定当前类为配置类
@ComponentScan("com.itheima")
//用于设定扫描路径，此注解只能添加一次，多个请用数组格式
public class SpringConfig {
}

```

```java
//读配置类
ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
```

- 作用范围和生命周期

  ```java
  @Repository
  @Scope("prototype")
  public class BookDaoImpl implements BookDao {
      public void save() {
          System.out.println("book dao save");
      }
      @PostConstruct//构造后
      public void init(){
          System.out.println("init");
      }
      @PreDestro//销毁前
      public void destory(){
          System.out.println("destory");
      }
  }
  
  ```

### 依赖注入

```java
@Configuration
@PropertySource("jdbc.properties")//加载数据源
@ComponentScan("com.itheima")
public class SpringConfig {
}

```

使用数据源后value可${}获取数据

```

@Repository("bookDao")
public class BookDaoImpl implements BookDao {
    @Value("${name}")
    private String name;
    public void save() {
        System.out.println("book dao save " + name);
    }
}

```

### 第三方依赖注入

- 第三方bean管理
  - @Bean

```java
public class JdbcConfig {
    //获得要管理的对象
    @Bean
    public DataSource dataSource(){
        DruidDataSource druidDataSource  = new DruidDataSource();
        druidDataSource.setDriverClassName("com.mysql.jdbc.Driver");
        druidDataSource.setUrl("jdbc:mysql://localhost:3306/mybatis");
        druidDataSource.setUsername("root");
        druidDataSource.setPassword("root");
        return druidDataSource;
    }
}

```

```java
@Configuration
@Import(JdbcConfig.class)//方式一导入式，如果导入多个用{}
public class SpringConfig {

}
```

```java
  AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        DataSource bean = context.getBean(DataSource.class);
        System.out.println(bean);
```

### 注解实现为第三方bean注入资源

- 简单类型依赖注入

- 引用类型依赖注入

  ```java
  
  public class JdbcConfig {
      //基本类型
      @Value("com.mysql.jdbc.Driver")
      private String driver;
      @Value("jdbc:mysql://localhost:3306/mybatis")
      private String url;
      @Value("root")
      private String username;
      @Value("root")
      private String password;
  
      //获得要管理的对象
      @Bean
      public DataSource dataSource(BookDao bookDao){//引用类型
          System.out.println(bookDao);
          DruidDataSource druidDataSource  = new DruidDataSource();
          druidDataSource.setDriverClassName(driver);
          druidDataSource.setUrl(url);
          druidDataSource.setUsername(username);
          druidDataSource.setPassword(password);
          return druidDataSource;
      }
  ```

## Spring整合mybatis

config

- JdbcConfig

```java

public class JdbcConfig {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;

    @Bean
    public DataSource dataSource(){
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setDriverClassName(driver);
        druidDataSource.setUrl(url);
        druidDataSource.setUsername(username);
        druidDataSource.setPassword(password);
        return druidDataSource;
    }
}

```

- MybatisConfig

  ```java
  public class MybatsiConfig {
      @Bean
      public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
          SqlSessionFactoryBean ssfb= new SqlSessionFactoryBean();
          ssfb.setTypeAliasesPackage("com.itheima.domain");
          ssfb.setDataSource(dataSource);
          return ssfb;
      }
      @Bean
      public MapperScannerConfigurer mapperScannerConfigurer(){
          MapperScannerConfigurer msc = new MapperScannerConfigurer();
          msc.setBasePackage("com.itheima.dao");
          return msc;
      }
  }
  ```

  

- SpringConfig

  ```java
  @Configuration
  @ComponentScan("com.itheima")
  @PropertySource("Jdbc.properties")
  @Import({JdbcConfig.class,MybatsiConfig.class})
  public class SpringConfig {
  }
  
  ```

  

## Spring整合Junit

- 使用Spring整合Junit专用类加载器以及上下文配置

```java
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTest {
    @Autowired//自动装配
    private AccountService accountService;
    @Test
    public void test(){
        System.out.println( accountService.findById(1));
//        Account{id=1, name='zhangsan', money='2000'}
    }

}
```

```xml
 <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
 </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>
```