Spring(二)

1. 基于注解的IOC配置

1.1 写在最前

学习基于注解的IoC配置，大家脑海里首先得有一个认知，即注解配置和xml配置要实现的功能都是一样的，都是要降低程序间的耦合。只是配置的形式不一样。

关于实际的开发中到底使用xml还是注解，每家公司有着不同的使用习惯。所以这两种配置方式我们都需要掌握。

1.2 环境搭建

1.2.1 拷贝必备jar包

注意：在基于xml的配置中，多拷贝一个aop的jar包。如下图：

image-20200611124335142

1.2.2 在类的根路径下创建任意名称的xml文件

1
2
3
4
5
6
7
8
9
10
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       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
                           http://www.springframework.org/schema/context
                           http://www.springframework.org/schema/context/spring-context.xsd">

</beans>

1.2.3 使用@Component注解配置管理的资源

1
2
3
4
5
6
7
8
9
10
11
12
13
/**
 * 客户的业务层实现类
 *
 * @author wgy
 */
@Component(value="customerService")
public class CustomerServiceImpl implements ICustomerService {
    
    @Override
    public void saveCustomer() {
        System.out.println("执行了保存客户");
    }
}

1.2.4 在Spring的配置文件中开启Spring对注解ioc的支持

1
2
3
4
5
6
7
8
9
10
11
12
13
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       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
                           http://www.springframework.org/schema/context
                           http://www.springframework.org/schema/context/spring-context.xsd">
    <!-- 告知spring在创建容器时要扫描的包。当配置了此标签之后，spring创建容器就会去指定的包及其子包下找对应的注解
         标签是在一个context的名称空间里，所以必须先导入context名称空间
     -->
    <context:component-scan base-package="com.wgy"/>
</beans>

1.3 常用注解

1.3.1 用于创建bean对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
相当于：<bean id="" class="">

@Component
    作用：就相当于配置了一个bean标签。
    它能出现的位置：类上面
    属性：
    	value：含义是指定bean的id。当不写时，它有默认值，默认值是：当前类的短名首字母改小写。
    	
由此注解衍生的三个注解：
    @Controller		一般用于表现的注解
    @Service		一般用于业务层
    @Repository		一般用于持久层
    他们和@Component的作用及属性都是一模一样
    细节：如果注解中有且只有一个属性要赋值时，且名称是value，value在赋值是可以不写。

1.3.2 用于注入数据的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
相当于：<property name="" ref=""> 	   
        <property name="" value="">

@Autowired
    作用：自动按照类型注入。只要有唯一的类型匹配就能注入成功。
        如果注入的bean在容器中类型不唯一时，它会把变量名称作为bean的id，在容器中查找，找到后也能注入成功。
        如果没有找到一致的bean的id，则报错。
        当我们使用注解注入时，set方法就不是必须的了。
        
@Qualifier
    作用：在自动按照类型注入的基础之上，再按照bean的id注入。
    	它在给类成员注入数据时，不能独立使用。但是再给方法的形参注入数据时，可以独立使用。
    属性：
    	value：用于指定bean的id。
    	
@Resource
    作用：直接按照bean的id注入。
    属性：
    	name：用于指定bean的id。
    	
以上三个注解都是用于注入其他bean类型的。用于注入基本类型和String类型需要使用Value

@Value:
    作用：用于注入基本类型和String类型数据。它可以借助Spring的el表达式读取properties文件中的配置。
    属性：
    	value：用于指定要注入的数据

1.3.3 用于改变作用范围的

1
2
3
4
5
6
7
相当于：<bean id="" class="" scope="">

@Scope
    作用：用于改变bean的作用范围
    属性：
        value：用于指定范围的取值。
        取值和xml中scope属性的取值是一样的。singleton prototype request session globalsession

1.3.4 和生命周期相关的

1
2
3
4
5
6
7
8
9
相当于：<bean id="" class="" init-method="" destroy-method="" />

@PostConstruct
    作用：
        用于指定初始化方法。

@PreDestroy
    作用：
        用于指定销毁方法。

1.3.5 代码示例

持久层

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/**
 * 客户的业务层实现类
 *
 * @author wgy
 */
@Service("customerService")
@Scope("singleton")
public class CustomerServiceImpl implements ICustomerService {

    @Value("泰斯特")
    private String name;

//  @Autowired
//  @Qualifier("customerDao1")
    @Resource(name="customerDao")
    private ICustomerDao customerDao = null;

    @Override
    public void saveCustomer() {
        System.out.println("业务层调用持久层......"+name);
        customerDao.saveCustomer();
    }

}

持久层

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/**
 * 模拟客户的持久层实现类
 *
 * @author wgy
 */
@Repository("customerDao")
public class CustomerDaoImpl implements ICustomerDao {

    @Override
    public void saveCustomer() {
        System.out.println("持久层保存了客户");
    }

}

1.3.6 关于Spring注解和XML的选择问题

1
2
3
4
注解的优势：
    配置简单，维护方便（我们找到类，就相当于找到了对应的配置）。
XML的优势：
    修改时，不用改源码。不涉及重新编译和部署。

Spring管理Bean方式的比较：

img

1.4 Spring的纯注解配置

1.4.1 待改造的问题

我们发现，之所以我们现在离不开xml配置文件，是因为我们有一句很关键的配置：

1
2
3
4
<!-- 告知spring在创建容器时要扫描的包。当配置了此标签之后，spring创建容器就会去指定的包及其子包下找对应的注解
    标签是在一个context的名称空间里，所以必须先导入context名称空间
-->
<context:component-scan base-package="com.wgy"/>

如果他要也能用注解配置，那么我们就可以脱离xml文件了。

1.4.2 使用注解配置要扫描的包

创建配置类：

1
2
3
4
5
6
7
8
9
10
11
/**
 * 一个spring的配置类
 * 它的作用就相当于bean.xml
 *
 * @author wgy
 */
@Configuration//它就是把当前类看成是spring的配置类
@ComponentScan({"com.wgy"})//配置要扫描的包
public class SpringConfiguration {
	
}

测试类获取容器:

1
2
3
4
5
6
7
8
9
public static void main(String[] args) {
    //1.获取容器：由于我们已经没有了xml文件，所以再用读取xml方式就不能用了。
    //这时需要指定加载哪个类上的注解
    ApplicationContext ac = 
        new AnnotationConfigApplicationContext(SpringConfiguration.class);
    //2.根据id获取对象
    ICustomerService cs = (ICustomerService) ac.getBean("customerService");
    cs.saveCustomer();
}

1.4.3 新注解说明

1.4.3.1 @Configuration

1
2
3
4
5
@Configuration
    作用：
        用于指定当前类是一个spring配置类，当创建容器时会从该类上加载注解。获取容器时需要使用AnnotationApplicationContext(有@Configuration注解的类.class)。
    属性：
        value:用于指定配置类的字节码

1.4.3.2 @ComponentScan

1
2
3
4
5
6
@ComponentScan
    作用：
        用于指定spring在初始化容器时要扫描的包。作用和在spring的xml配置文件中的：
        <context:component-scan base-package="com.wgy"/>是一样的。
    属性：
        basePackages：用于指定要扫描的包。和该注解中的value属性作用一样。

1.4.3.3 @PropertySource

1
2
3
4
5
@PropertySource
    作用：
        用于加载.properties文件中的配置。例如我们配置数据源时，可以把连接数据库的信息写到properties配置文件中，就可以使用此注解指定properties配置文件的位置。
    属性：
        value[]：用于指定properties文件位置。如果是在类路径下，需要写上classpath:

1.4.3.4 @Import

1
2
3
4
5
@Import
    作用：
        用于导入其他配置类，在引入其他配置类时，可以不用再写@Configuration注解。当然，写上也没问题。
    属性：
        value[]：用于指定其他配置类的字节码。

1.4.3.5 @Bean

1
2
3
4
5
@Bean
    作用：
        该注解只能写在方法上，表明使用此方法创建一个对象，并且放入spring容器。它就相当于我们之前在xml配置中介绍的factory-bean和factory-method。
    属性：
        name：给当前@Bean注解方法创建的对象指定一个名称(即bean的id）。

1.4.3.6 代码示例

jdbcConfig.properties:

1
2
3
4
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring
jdbc.username=root
jdbc.password=root

Jdbc的配置类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
/**
 * Jdbc的配置类
 *
 * @author wgy
 */
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(name = "runner")//它是把方法的返回值存入Spring容器中。该注解有一个属性，name：用于指定bean的id。当不指定时它有默认值，默认值是方法的名称。
    public QueryRunner createQueryRunner(@Qualifier("ds1") DataSource dataSource) {
        return new QueryRunner(dataSource);
    }

    @Bean(name = "ds")
    public DataSource createDataSource() {
        try {
            System.out.println(driver);//com.mysql.jdbc.Driver
            ComboPooledDataSource ds = new ComboPooledDataSource();
            ds.setDriverClass(driver);
            ds.setJdbcUrl(url);
            ds.setUser(username);
            ds.setPassword(password);
            return ds;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Bean(name = "ds1")
    public DataSource createDataSource1() {
        try {
            System.out.println(url);
            ComboPooledDataSource ds = new ComboPooledDataSource();
            ds.setDriverClass(driver);
            ds.setJdbcUrl(url);
            ds.setUser(username);
            ds.setPassword(password);
            return ds;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

配置类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
/**
 * 一个spring的配置类
 * 它的作用就相当于bean.xml
 *
 * @author wgy
 */
@Configuration//它就是把当前类看成是spring的配置类
@ComponentScan({"com.wgy"})
@Import({JdbcConfig.class})//导入其他配置类
@PropertySource({"classpath:config/jdbcConfig.properties"})
public class SpringConfiguration {

    /**
     * Spring EL表达式失效问题：
     * 	目前使用的版本是4.2.4,在spring4.3以前都需要提供一个占位符配置器：
     * 		PropertySourcesPlaceholderConfigurer
     * 	而在spring4.3以后，则不需要提供。
     * 	提供的方式如下：（在SpringConfiguration或JdbcConfig中配置均可）
     *
     * @return
     */
    @Bean
    public static PropertySourcesPlaceholderConfigurer createPropertySourcesPlaceholderConfigurer(){
        return  new PropertySourcesPlaceholderConfigurer();
    }

}

2. Spring整合Junit

2.1 准备测试环境

2.1.1 创建业务层接口实现类

1
2
3
4
5
6
7
8
9
10
11
12
/**
 * 客户的业务层接口
 */
public interface ICustomerService {

    /**
     * 查询所有客户
     * @return
     */
    List<Customer> findAllCustomer();

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/**
 * 客户的业务层实现类
 */
public class CustomerServiceImpl implements ICustomerService {

    private ICustomerDao customerDao;
    
    public void setCustomerDao(ICustomerDao customerDao) {
        this.customerDao = customerDao;
    }
    
    @Override
    public List<Customer> findAllCustomer() {
        return customerDao.findAllCustomer();
    }

}

2.1.2 创建持久层接口实现类

1
2
3
4
5
6
7
8
9
10
11
12
/**
 * 客户的持久层接口
 */
public interface ICustomerDao {
	
    /**
     * 查询所有客户
     * @return
     */
    List<Customer> findAllCustomer();

}
1
2
3
4
5
6
7
8
9
10
11
12
/**
 * 客户的持久层实现类
 */
public class CustomerDaoImpl implements ICustomerDao {

    @Override
    public List<Customer> findAllCustomer() {
        System.out.println("查询了所有客户");
        return null;
    }

}

2.1.3 导入junit的jar包

image-20200611141929079

2.1.4 编写测试类

1
2
3
4
5
6
7
8
9
10
11
12
/**
 * 测试客户的业务层和持久层
 */
public class CustomerServiceTest {

    private ICustomerService customerService;
    
    @Test
    public void testFindAll(){
        customerService.findAllCustomer();
    }
}

2.2 使用xml配置步骤

2.2.1 xml文件中的配置

1
2
3
4
5
6
7
8
9
10
11
12
<?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">
	<!-- 把资源交给spring来管理 -->
	<bean id="customerDao" class="com.wgy.dao.impl.CustomerDaoImpl"></bean>
	
	<bean id="customerService" class="com.wgy.service.impl.CustomerServiceImpl">
		<property name="customerDao" ref="customerDao"></property>
	</bean>
</beans>

2.2.2 拷贝整合junit的必备jar包

image-20200611142214483

2.2.3 使用@RunWith注解替换原有运行器

1
2
3
4
5
6
7
8
9
10
11
@RunWith(SpringJUnit4ClassRunner.class)
public class CustomerServiceTest {
	
    private ICustomerService customerService;
    
    @Test
    public void testFindAll(){
        customerService.findAllCustomer();
    }
	
}

2.2.4 使用@ContextConfiguration指定spring配置文件的位置

1
2
3
4
5
6
7
8
9
10
11
12
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:bean.xml"})
public class CustomerServiceTest {

    private ICustomerService customerService;
    
    @Test
    public void testFindAll(){
        customerService.findAllCustomer();
    }
	
}

2.2.5 使用@Autowired给测试类中的变量注入数据

1
2
3
4
5
6
7
8
9
10
11
12
13
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:bean.xml"})
public class CustomerServiceTest {

    @Autowired
    private ICustomerService customerService;
    
    @Test
    public void testFindAll(){
        customerService.findAllCustomer();
    }

}

2.3 使用纯注解配置步骤

2.3.1 拷贝整合junit的必备jar

image-20200611142214483

2.3.2 把资源都用注解管理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
 * 客户的业务层实现类
 */
@Service("customerService")
public class CustomerServiceImpl implements ICustomerService {

    @Autowired
    private ICustomerDao customerDao;
    
    @Override
    public List<Customer> findAllCustomer() {
        return customerDao.findAllCustomer();
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
/**
 * 客户的持久层实现类
 */
@Repository("customerDao")
public class CustomerDaoImpl implements ICustomerDao {

    @Override
    public List<Customer> findAllCustomer() {
        System.out.println("查询了所有客户");
        return null;
    }

}

2.3.3 使用注解配置方式创建Spring容器

1
2
3
4
5
6
7
8
9
10
11
12
13
@Configuration
@ComponentScan(basePackages={"com.wgy"})
public class CustomerServiceTest {

    @Autowired
    private ICustomerService customerService;
    
    @Test
    public void testFindAll(){
        customerService.findAllCustomer();
    }

}

2.3.4 使用RunWith注解和ContextConfiguration注解配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes={CustomerServiceTest.class})
@Configuration
@ComponentScan(basePackages={"com.wgy"})
public class CustomerServiceTest {

    @Autowired
    private ICustomerService customerService;
    
    @Test
    public void testFindAll(){
        customerService.findAllCustomer();
    }
	
}

2.4 为什么不把测试类配到xml中

  1. 当我们在xml中配置了一个bean，Spring加载配置文件创建容器时，就会创建对象。
  2. 测试类只是我们在测试功能时使用，而在项目中它并不参与程序逻辑，也不会解决需求上的问题，所以创建完了，并没有使用。那么存在容器中就会造成资源的浪费。


-------------本文结束感谢您的阅读-------------



本文作者： Wgy
本文标题： Spring(二)
本文链接： https://wgy1993.gitee.io/archives/16fa518f.html
版权声明： 本作品采用 CC BY-NC-SA 4.0 进行许可。转载请注明出处！
知识共享许可协议
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

微信分享二维码

本站总访问量:

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

程序员的一天