Spring笔记

写此系列的目的是做一个学习笔记管理，方便以后复习用。

Spring是轻代码，重配置的框架。

Spring是分层的 Java SE/EE应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control：反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为内核。

提供了展现层 SpringMVC 和持久层 Spring JDBCTemplate 以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE 企业应用开源框架。

Spring框架的核心功能：

创建管理所有的Java对象，这些对象被称为Bean。

参考文档

参考视频

Spring快速入门

1. 导入Spring开发的基本包坐标

   pom.xml

   <properties>  
       <spring.version>5.0.5.RELEASE</spring.version>
   </properties>
   
   <dependencies>
       <!--导入spring的context坐标，context依赖core、beans、expression-->
       <dependency>    
           <groupId>org.springframework</groupId>    
           <artifactId>spring-context</artifactId>    
           <version>${spring.version}</version>  
       </dependency>
   </dependencies>

2. 编写Dao接口和实现类

   public interface UserDao {
       public void save();
   }
   
   public class UserDaoImpl implements UserDao {    
       @Override
       public void save() {
           System.out.println("UserDao save method running....");
       }
   }

3. 创建Spring核心配置文件

   在类路径下（resources）创建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配置文件中配置UserDaoImpl

   <?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="userDao" class="com.itheima.dao.impl.UserDaoImpl"></bean>
   </beans>

5. 使用Spring的API获得Bean实例

   @Test
   public void test1(){
       ApplicationContext applicationContext = new  
                ClassPathXmlApplicationContext("applicationContext.xml");
       UserDao userDao = (UserDao) applicationContext.getBean("userDao");
       userDao.save();
   }

Spring配置文件

重要配置标签

<bean>标签
    id属性:在容器中Bean实例的唯一标识，不允许重复
    class属性:要实例化的Bean的全限定名
    scope属性:Bean的作用范围，常用是Singleton(默认)和prototype
    <property>标签：属性注入
        name属性：属性名称
        value属性：注入的普通属性值
        ref属性：注入的对象引用值
        <list>标签
        <map>标签
		<properties>标签
    <constructor-arg>标签
<import>标签:导入其他的Spring的分文件

Bean实例化的三种方式

无参构造方法实例化

<bean id = "userDao" class = "com.itheima.dao.impl.UserDaoImpl"></bean>

工厂静态方法实例化

工厂实例方法实例化

Bean的依赖注入

依赖注入（Dependency Injection）：它是 Spring 框架核心 IOC（反转控制） 的具体实现。

在编写程序时，通过控制反转，把对象的创建交给了 Spring，但是代码中不可能出现没有依赖的情况。
IOC 解耦只是降低他们的依赖关系，但不会消除。例如：业务层仍会调用持久层的方法。

用依赖注入的方式管理Bean之间的依赖关系。依赖注入可以让Bean以配置文件组织在一起，是一种优秀的解耦方式。

依赖注入有两种方式，set注入和构造注入。（设计模式解耦合）

set注入和构造注入

<!--set方式注入-->
<bean id="userDao" class="com.tsuki.dao.impl.UserDaoImpl"></bean>
<bean id="userService" class="com.tsuki.service.impl.UserServiceImpl">
    <!--set方法后的名字是name，ref是指向注入的UserDao的id-->
    <property name="userDao" ref="userDao"></property>
</bean>

<!--构造器方式注入-->
<bean id="userDao" class="com.tsuki.dao.impl.UserDaoImpl"></bean>
<bean id="userService" class="com.tsuki.service.impl.UserServiceImpl">
    <constructor-arg name="userDao" ref="userDao"></constructor-arg>
</bean>

相关API

applicationContext：接口类型，代表应用上下文，可以通过其实例获得 Spring 容器中的 Bean 对象

ApplicationContext的实现类

1）ClassPathXmlApplicationContext
它是从类的根路径下加载配置文件 推荐使用这种
2）FileSystemXmlApplicationContext
它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。
3）AnnotationConfigApplicationContext
当使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解。

ApplicationContext app = new ClasspathXmlApplicationContext("xml文件");
app.getBean("id");
app.getBean(Class);

Spring配置数据源（连接池）

druid步骤：

1. 导入依赖 pom.xml

   <!--mysql驱动-->
   <dependency>
       <groupId>mysql</groupId>
       <artifactId>mysql-connector-java</artifactId>
       <version>5.1.26</version>
       <scope>compile</scope>
   </dependency>
   
   <!--druid连接池-->
   <dependency>
       <groupId>com.alibaba</groupId>
       <artifactId>druid</artifactId>
       <version>1.0.9</version>
   </dependency>
   
   <!--导入Junit-->
   <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
       <!--版本要求高于4.11-->
       <version>4.13</version>
       <scope>test</scope>
   </dependency>
   <dependency>
       <groupId>org.junit.jupiter</groupId>
       <artifactId>junit-jupiter</artifactId>
       <version>RELEASE</version>
       <scope>compile</scope>
   </dependency>

2. 创建DataSource 在Spring中采用注入容器的方法 applicationContext.xml

   <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
       <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
       <property name="url" value="jdbc:mysql://localhost:3306/db1"></property>
       <property name="username" value="root"></property>
       <property name="password" value="root"></property>
   </bean>

   • 将参数提取到properties文件中后如何注入容器

     1.需要引入context的命名空间和约束路径

     • 命名空间 xmlns:context="http://www.springframework.org/schema/context"
     • 约束路径 http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
     • applicationContext.xml

     <!--加载外部配置文件，classpath是从类加载文件resources中加载-->
     <context:property-placeholder location="classpath:jdbc.properties"/>
     
     <!--注入datasource-->
     <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
         <!--spl表达式，类似el表达式的用法 value="${key}"-->
         <property name="driverClassName" value="${jdbc.driverClassName}"></property>
         <property name="url" value="${jdbc.url}"></property>
         <property name="username" value="${jdbc.username}"></property>
         <property name="password" value="${jdbc.password}"></property>
     </bean>

3. 使用

   @Test
   public void test2() throws SQLException {
       ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");//加载Spring的配置文件
       //从容器中获取对象
       DataSource ds = (DataSource) applicationContext.getBean("dataSource");
       Connection conn = ds.getConnection();
       System.out.println(conn);
       conn.close();
   }

注解开发

简化和舍弃Spring的配置文件，方便快捷

• 原始注解

  1. @Component <bean id="userDao" class="com.tsuki.dao.impl.UserDaoImpl"></bean>

     @Controller @Service @Repository

  2. @Autowired @Qualifier---@Resource按名称注入

     <bean id="userService" class="com.tsuki.service.impl.UserServiceImpl">
         <property name="userDao" ref="userDao"></property>
     </bean>

  3. @Value(普通属性) @Scope

• 配置组件扫描

  <!--配置组件扫描-->
     <context:component-scan base-package="com.tsuki" />

• 新注解开发—全注解开发

  旧注解有几方面不能满足

  @Configuration Spring的核心配置类，用类的方式替代xml文件， 注解的方式替代标签

  1. 非自定义的bean @Bean("dataSource")
  2. 配置文件properties @PropertySource("classpath:jdbc.properties")
  3. 组件扫描 @ComponentScan("com.tsuki")
  4. 引入import @Import

Junit的集成

1. 导入spring集成Junit坐标 pom.xml

   <!--导入Junit-->
   <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
       <!--版本要求高于4.11-->
       <version>4.13</version>
       <scope>test</scope>
   </dependency>
   <dependency>
       <groupId>org.junit.jupiter</groupId>
       <artifactId>junit-jupiter</artifactId>
       <version>RELEASE</version>
       <scope>compile</scope>
   </dependency>
   <!--导入spring的test坐标-->
   <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-test</artifactId>
       <version>${spring.version}</version>
   </dependency>

2. @Runwith代替原来运行周期 @RunWith(SpringJUnit4ClassRunner.class)

3. @ContextConfiguration指定配置文件或配置类 @ContextConfiguration("classpath:applicationContext.xml")

4. @Autowired注入需要测试的对象

5. 创建测试方法进行测试

AOP

事务控制

未完待续。。。