[Java知识库]Spring知识点整理

Spring开发步骤

第一步：导入坐标

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

第二步：

创建bean
创建配置文件
在配置文件进行配置

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

第三步：

创建ApplicationContext对象getBean

Spring配置文件

Bean标签基本配置

id：Bean实例在Spring容器中的唯一标识
class：Bean的全限定名称
name：bean的名称，可以通过name值获取bean，用于多人配合时给bean起别名

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

Bean标签范围配置

scope：指对象的作用范围
取值：
singleton：设定创建出的对象保存在spring容器中，是一个单例的对象,默认值
prototype：设定创建出的对象保存在spring容器中，是一个非单例的对象
request、session、application、 websocket ：设定创建出的对象放置在web容器对应的位置

<bean id="userDao" class="com.zengqh.dao.impl.UserDaoImpl" scope="prototype"></bean>

    @Test
//    测试单例模式
    public void test1(){
        ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao1 = (UserDao) app.getBean("userDao");
        UserDao userDao2 = (UserDao) app.getBean("userDao");
        System.out.println(userDao1);
        System.out.println(userDao2);
        //com.zengqh.dao.impl.UserDaoImpl@34c4973
        //com.zengqh.dao.impl.UserDaoImpl@34c4973
    }

    @Test
//    测试多例模式
    public void test2(){
        ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao1 = (UserDao) app.getBean("userDao");
        UserDao userDao2 = (UserDao) app.getBean("userDao");
        System.out.println(userDao1);
        System.out.println(userDao2);
//        com.zengqh.dao.impl.UserDaoImpl@11438d26
//        com.zengqh.dao.impl.UserDaoImpl@34cd072c
    }

区别

当scope的取值为singleton时
Bean的实例化个数：1个
Bean的实例化时机：当Spring核心文件被加载时,实例化配置的Bean实例

ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
也就是上述代码执行时，实例化配置的Bean实例

Bean的生命周期
对象创建：当应用加载，创建Spring容器时，对象就被创建了
对象运行：只要Spring容器在，对象一直活着
对象销毁：当应用卸载，销毁容器时，对象就被销毁了

当scope的取值为prototype时
Bean的实例化个数：多个
Bean的实例化时机：当调用getBean()方法时实例化Bean实例

ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
UserDao userDao1 = (UserDao) app.getBean("userDao");

Bean的生命周期
对象创建：当使用对象时，创建新的对象实例
对象运行：只要对象在使用中，就一直或者
对象销毁：当对象长时间不用时，被 Java 的垃圾回收期回收

Bean的生命周期

init-method="init" 
destroy-method="destroy"

<bean id="userDao" class="com.zengqh.dao.impl.UserDaoImpl" scope="prototype" init-method="init" destroy-method="destroy"></bean>

Bean实例化的三种方式

无参构造方法实例化(重要)
工厂静态方法实例化(了解)
工厂实例方法实例化(了解)

无参构造方法实例化

它会根据默认无参构造方法来创建类对象，如果bean中没有默认无参构造函数，将会创建失败

<bean id="userDao" class="com.zengqh.dao.impl.UserDaoImpl" scope="prototype"></bean>

工厂静态方法实例化

使用class属性来指定包含static工厂方法的类的全限名
使用factory-method 属性来指定工厂方法本身的名称

/**
 * 工厂静态方法
 */
public class StaticFactory {
    public static UserDao getUserDao(){
        return new UserDaoImpl();
    }
}

在Spring核心配置文件配置

<!--    工厂静态方法创建对象-->
<bean id="userDao" class="com.zengqh.factory.StaticFactory"  factory-method="getUserDao"></bean>

工厂实例方法实例化

使用此机制，请将class属性留空，并在factory-bean属性中，指定包含要创建对象的实例方法的bean的名称
使用factory-method属性设置工厂方法本身的名称
编写工厂实例方法
/**
 * 工厂实例方法创建对象
 */
public class DynamicFactory {
    public  UserDao getUserDao(){
        return new UserDaoImpl();
    }

在Spring核心配置文件配置

<!--    工厂实例方法创建对象-->
<bean id="userDao" class="com.zengqh.factory.StaticFactory"  factory-method="getUserDao"></bean>

Spring依赖注入（ Dependency Injection）

依赖注入 Dependency Injection：它是Spring框架核心IOC的具体实现

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

简单的说，就是坐等框架把持久层(Dao)对象传入业务层(Service)，而不用我们自己去获取

依赖注入方式

• 构造方法

• set方法

构造方法

UserServiceImpl中创建构造方法

public class UserServiceImpl implements UserService {
    private UserDao userDao;

    public UserServiceImpl() {
    }

    public UserServiceImpl(UserDao userDao) {
        this.userDao = userDao;
    }
    @Override
    public void save() {
        userDao.save();
    }
}

Spring配置文件

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

<bean id="userService" class="com.zengqh.service.impl.UserServiceImpl">
    <constructor-arg name="userDao" ref="userDao"></constructor-arg>
</bean>

set方法

UserServiceImpl中声明set

public class UserServiceImpl implements UserService {
    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

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

Spring配置文件

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

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

简单方法

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

<bean id="userService" class="com.zengqh.service.impl.UserServiceImpl" p:userDao-ref="userDao"></bean>

依赖注入的数据类型

普通数据类型

<bean id="userDao" name="userDaoImpl02" class="com.zengqh.dao.impl.UserDaoImpl02">
    <property name="age" value="22"></property>
    <property name="username"   value="ZQH"></property>
</bean>

引用数据类型

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

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

集合数据类型

<bean id="userDao" class="com.zengqh.dao.impl.UserDaoImpl03">
    <property name="userList">
        <list>
            <value>ZQH</value>
        </list>
    </property>
    <property name="userMap">
        <map>
            <entry key="ZQH" value-ref="user1"></entry>
            <entry key="ABC" value-ref="user1"></entry>
        </map>
    </property>
    <property name="properties">
        <props>
            <prop key="p1">ZQH</prop>
            <prop key="p2">ABC</prop>
        </props>
    </property>
</bean>
<bean id="user1" class="com.zengqh.domain.User">
    <property name="name" value="ZQH"></property>
    <property name="age"    value="22"></property>
</bean>

配置文件的导入

引入其他分类的配置文件

<import resource="applicationContext-02.xml"></import>

SpringAPI

ClassPathXmlApplicationContext 实际开发中都是读取类路径, 它是用于读取类路径下的配置文件

FileSystemXmlApplicationContext 它是用于读取系统文件目录中的配置文件

AnnotationConfigApplicationContext() 基于注解的实现类
(当我们使用注解配置容器时,需要使用此类来创建spring容器,它用来读取注解)

    ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
ApplicationContext app = new FileSystemXmlApplicationContext("E:\\...\\src\\main\\resources\\applicationContext.xml");
 

getBean

public Object getBean(String name) throws BeansException {
    this.assertBeanFactoryActive();
    return this.getBeanFactory().getBean(name);
}

public <T> T getBean(Class<T> requiredType) throws BeansException {
    this.assertBeanFactoryActive();
    return this.getBeanFactory().getBean(requiredType);
}

实例
    UserService userService = (UserService) app.getBean("userService");
	UserService bean = app.getBean(UserService.class);

Spring数据源配置

开发步骤

导入依赖

创建数据源对象

设置数据源的基本连接数据

使用数据源获取连接资源，归还资源

手动连接数据源

@Test
//测试手动创建c3p0数据源
public void test1() throws Exception {
    ComboPooledDataSource dataSource = new ComboPooledDataSource();
    dataSource.setDriverClass("com.mysql.jdbc.Driver");
    dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/spring-test-db");
    dataSource.setUser("root");
    dataSource.setPassword("123456");
    Connection connection = dataSource.getConnection();
    System.out.println(connection);
    connection.close();
}

@Test
//测试手动创建druid数据源
public void test2() throws Exception{
    DruidDataSource dataSource = new DruidDataSource();
    dataSource.setDriverClassName("com.mysql.jdbc.Driver");
    dataSource.setUrl("jdbc:mysql://localhost:3306/spring-test-db");
    dataSource.setUsername("root");
    dataSource.setPassword("123456");
    Connection connection = dataSource.getConnection();
    System.out.println(connection);
    connection.close();

}

Spring配置数据源

c3p0

@Test
//Spring读取配置
public void test02() throws Exception{
    ApplicationContext app =new ClassPathXmlApplicationContext("applicationContext.xml");
    DataSource dataSource = app.getBean(DataSource.class);
    Connection connection = dataSource.getConnection();
    System.out.println(connection);
    connection.close();
}

Spring配置文件

<!--加载外部的properties文件  注意要导入一下命名空间-->
    <context:property-placeholder location="jdbc.properties"/>
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

属性名要跟数据源的属性对应

@Test
//测试手动创建c3p0数据源
public void test1() throws Exception {
    ComboPooledDataSource dataSource = new ComboPooledDataSource();
    dataSource.setDriverClass("com.mysql.jdbc.Driver");
    dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/spring-test-db");
    dataSource.setUser("root");
    dataSource.setPassword("123456");
    Connection connection = dataSource.getConnection();
    System.out.println(connection);
    connection.close();
}

Deruid

<!--    druid-->
    <context:property-placeholder location="jdbc.properties"/>
    <bean id="dataSource" 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>

Spring注解开发

原始注解

用注解来替代Bean的配置

注解	       说明
@Component	使用在类上个用于实例化Bean
@Controller	使用在web层类上用于实例化Bean
@Service	使用在service层类上用于实例化Bean
@Repository	使用在dao层类上用于实例化Bean
@Autowired	使用在字段上上用于根据类型依赖注入
@Qualifier	结合@Autowired一起使用用于根据名称进行依赖注入
@Resource	相当于@Autowired + @Qualifier，按照名称进行注入
@Value		注入普通属性
@Scope		标注Bean的作用范围
@PostConstruct	使用在方法上标注方法是Bean的初始化方法
@PreDestroy		使用在方法上标注该方法是Bean的销毁方法

使用注解进行开发时，需要在applicationContext.xml中配置组件扫描，作用是指定哪个包及其子包下的Bean需要进行扫描以便识别使用注解配置的类、字段和方法

<context:component-scan base-package="com.zengqh"/>

• 在进行包所扫描时，会对配置的包及其子包中所有文件进行扫描
• 扫描过程是以文件夹递归迭代的形式进行的
• 扫描过程仅读取合法的java文件
• 扫描时仅读取spring可识别的注解
• 扫描结束后会将可识别的有效注解转化为spring对应的资源加入IoC容器

Bean的实例化

• 类型：类注解
• 位置：类定义上方
• value:beanid

@Component

使用在类上个用于实例化Bean

<bean id="userDao" class="com.zengqh.dao.impl.UserDaoImpl"/>
<bean id="userService" class="com.zengqh.service.impl.UserServiceImpl">
</bean>

@Component("userDao")
@Component("userService")

@Controller

@Service

@Repository

使用在controller层/service层/dao层类上用于实例化Bean

@Service("userDao")
@Repository("userService")

Bean的引用类型属性注入

@Autowired

@Qualifier

• 名称：@Autowired、@Qualifier
• 类型：属性注解、方法注解
• 位置：属性定义上方，方法定义上方
• 作用：设置对应属性的对象或对方法进行引用类型传参

可以不用写set方法

@Autowired 按照数据类型从Spring容器中进行匹配
@Qualifier("userDao") 按照id值从容器中进行匹配的
@Resource(name="userDao")  相当于@Autowired+@Qualifier("userDao") 

作用域注解

@Scope

使用@Scope标注Bean的范围

• 名称：@Scope
• 类型：类注解
• 位置：类定义上方

//@Scope("prototype")
@Scope("singleton")
public class UserDaoImpl implements UserDao{  
}

Spring新注解

@Configuration    
作用：指定当前类是一个配置类，等同于applicationContext.xml
 
 
@ComponentScan    
    作用：用于通过注解指定spring在创建容器时要扫描的包
    属性：value，basePackages（两个属性别名互相引用，所以作用相同）指定要扫描的包
使用注解@ComponentScan(basePackages = {"com.study"})作用等同于
在xml中配置了<context:component-scan base-package="com.study"></context:component-scan>
 
 
@Bean    
    作用：用于把当前方法的返回值作为bean对象存入spring的ioc容器中
    属性：name:用于指定bean的id，当不写时，默认值时当前方法的名称
    细节：当使用注解配置方法时，如果方法有参数，spring会去容器中查找有没有可用的bean对象
    查找的方式和Autowired相同，根据类型匹配，有一个注入成功，没有注入失败，有多个会找bean的id和该参数名相同的进行匹配
    如果有多个，可以在参数前使用@Qualifier("")注解指定容器中的bean（单独使用的情况）
    @Bean
    public JdbcTemplate createJdbcTemplate(@Qualifier("ds1") DataSource dataSource){
        return new JdbcTemplate(dataSource);
    }
 
 
@Scope    
作用：声明此bean对象是多例的
 
 
@Import    
    作用：导入其他配置类
    参数：value:用于指定其他配置类的字节码
        当我们使用@Import后，当前类为主配置类，导入的为子配置类
 
@PropertySource    
    作用：用于指定properties文件的位置
    属性：value：指定文件的名称和路径
        关键字：classpath：表示类路径下
        @PropertySource("classpath:jdbc.properties")

Spring集成Junit

使用Junit测试Spring的项目时，由于不会创建spring的容器，所以会出现一些问题
所以Spring整合了Junit，使用步骤

1导入Spring整合Junit的jar包（坐标） spring-test依赖和Junit依赖

<!--        spring-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.9.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.1.9.RELEASE</version>

        </dependency>
<!--        测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>

2使用Junit提供的一个注解把原有的main方法替换了，替换成Spring提供的

@RunWith

@RunWith(SpringJUnit4ClassRunner.class)

•    spring-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.1.9.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.1.9.RELEASE</version>
  
    </dependency>
  

    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>

2使用Junit提供的一个注解把原有的main方法替换了，替换成Spring提供的

@RunWith        

@RunWith(SpringJUnit4ClassRunner.class)