解析Spring第二天

目的：使用spring中纯注解的方式

前言：同样是使用idea创建一个普通的maven工程（如何创建一个普通的Maven工程可以参考mybatis入门第一天的详解）。

bean管理类常用的4个注解（作用相同，推荐使用在不同分层上）

@Component 普通的类

@Controller 表现层

@Service 业务层

@Repository 持久层

依赖注入常用的注解

@Value 用于注入普通类型（String，int，double等类型）

@Autowired 默认按类型进行自动装配（引用类型）

@Qualifier 和@Autowired一起使用，强制使用名称注入

@Resource Java提供的注解，也被支持。使用name属性，按名称注入

对象生命周期（作用范围）注解

@Scope 生命周期注解，取值singleton（默认值，单实例）和prototype（多例）

以上具体的使用方式在以下的项目中在具体分析。

首先看一下，搭建项目的结构

引入开发需要的坐标

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <project xmlns="http://maven.apache.org/POM/4.0.0"
 3          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 5     <modelVersion>4.0.0</modelVersion>
 6 
 7     <groupId>zh.test.spring</groupId>
 8     <artifactId>spring_day02</artifactId>
 9     <version>1.0-SNAPSHOT</version>
10 
11 
12     <dependencies>
13         <dependency>
14             <groupId>org.springframework</groupId>
15             <artifactId>spring-context</artifactId>
16             <version>5.0.2.RELEASE</version>
17         </dependency>
18         <dependency>
19             <groupId>commons-logging</groupId>
20             <artifactId>commons-logging</artifactId>
21             <version>1.2</version>
22         </dependency>
23         <dependency>
24             <groupId>log4j</groupId>
25             <artifactId>log4j</artifactId>
26             <version>1.2.12</version>
27         </dependency>
28         <dependency>
29             <groupId>junit</groupId>
30             <artifactId>junit</artifactId>
31             <version>4.12</version>
32             <scope>test</scope>
33         </dependency>
34         <!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
35         <dependency>
36             <groupId>com.alibaba</groupId>
37             <artifactId>druid</artifactId>
38             <version>1.1.13</version>
39         </dependency>
40 
41         <dependency>
42             <groupId>org.springframework</groupId>
43             <artifactId>spring-test</artifactId>
44             <version>5.0.2.RELEASE</version>
45             <scope>test</scope>
46         </dependency>
47     </dependencies>
48 </project>

在demo文件下分别添加接口UserService和UserDaoService并分别实现接口》》》UserServiceImpl和UserDaoImpl。如下

　　创建UserDaoService接口。

1 package zh.test.demo;
2 
3 //编写一个简单的保存方法
4 public interface UserDaoService {
5     public void save();
6 }

　　实现UserDaoService接口，创建UserDaoImpl类

 1 package zh.test.demo;
 2 
 3 import org.springframework.stereotype.Repository;
 4 
 5 //在Dao（持久）层使用@Repository的注解方式，将这个类放到spring的IOC容器中
 6 @Repository("UserDao")
 7 public class UserDaoImpl implements UserDaoService {
 8     public void save() {
 9         System.out.println("持久层数据。。。");
10     }
11 }

　　创建UserService接口，

1 package zh.test.demo;
2 
3 public interface UserService {
4     public void save();
5 }

　　实现UserService接口，创建UserServiceImpl。

 1 package zh.test.demo;
 2 
 3 import org.springframework.beans.factory.annotation.Autowired;
 4 import org.springframework.beans.factory.annotation.Qualifier;
 5 import org.springframework.beans.factory.annotation.Value;
 6 import org.springframework.stereotype.Component;
 7 
 8 import javax.annotation.Resource;
 9 import javax.naming.Name;
10 
11 //@Component
12 //public class UserServiceImpl
13 //   相当于
14 //<bean id="userServiceImpl" class="zh.test.demo.UserServiceImpl"></bean>
15 
16 //@Component("us")
17 //含义：把当前的类存放到IOC容器中，默认的ID值是首字母小写的类名。
18 // 如果属性是value，而且只写了一个属性，那么value是可以省略不写的
19 @Component("us")
20 public class UserServiceImpl implements UserService {
21 //    @Value("lebron") 给属性注入值，在使用这种方式给属性注入值得时候，那么就不用提供set方法也是可以的
22     @Value("lebron")
23     private String name;
24 
25 //    public void setName(String name) {
26 //        this.name = name;
27 //    }
28 
29     //@Autowired   按照类型注入  没有按照ID的方式注入（和ID没有关系）。
30     //@Qualifier(value = "UserDao")  注入的时候根据名字注入。和UserDaoImpl 上注入的名字要相同。
31     //如果使用@Resource(name = "UserDao") 这个方式注解，则这一个相当于上面那两个注解
32 //    @Autowired
33 //    @Qualifier(value = "UserDao")
34 
35     @Resource(name = "UserDao")
36     private UserDaoService userDaoService;
37 
38 
39     public void setUserDaoService(UserDaoService userDaoService) {
40         this.userDaoService = userDaoService;
41     }
42 
43     public void save() {
44         userDaoService.save();
45         System.out.println("注解的方式。。。"+name);
46     }
47 }

在demo1的文件下使用纯注解的方式

　　创建DeptService接口　　

1 package zh.test.demo1;
2 
3 public interface DeptService {
4     public void find();
5 }

　　实现接口DeptService，创建类DeptServiceImpl

 1 package zh.test.demo1;
 2 
 3 import org.springframework.stereotype.Service;
 4 
 5 @Service("deptService")
 6 public class DeptServiceImpl implements  DeptService {
 7     public void find() {
 8         System.out.println("service.....");
 9     }
10 }

　　新建一个Java类为AnnotationProperties，当做配置文件使用，使用方式如下

 1 package zh.test.demo1;
 2 
 3 import com.alibaba.druid.pool.DruidDataSource;
 4 import org.springframework.context.annotation.Bean;
 5 import org.springframework.context.annotation.ComponentScan;
 6 import org.springframework.context.annotation.Configuration;
 7 
 8 import javax.sql.DataSource;
 9 
10 @Configuration  //声明当前类是配置类
11 @ComponentScan(value = "zh.test.demo1")    //指定扫描的包
12 public class AnnotationProperties {
13 
14 //    @Bean注解    只能写在方法上，表明使用此方法创建一个对象，对象创建完成保存到IOC容器中
15     /*
16     <!--配置bean的标签-->
17         <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
18             <property name="driverClassName" value="com.mysql.jdbc.Driver" />
19             <property name="url" value="jdbc:mysql://localhost:3306/xxx" />
20             <property name="username" value="root" />
21             <property name="password" value="root" />
22         </bean>
23      */
24     @Bean(name = "dataSource")
25     public DataSource dataSource()
26     {
27         DruidDataSource datasource=new DruidDataSource();
28         datasource.setDriverClassName("com.alibaba.druid.pool.DruidDataSource");
29         return datasource;
30     }
31 }

在resources文件下创建一个applicationContext.xml的配置文件。在这里主要适用于配置开启注解扫描。

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:util="http://www.springframework.org/schema/util"
 4        xmlns:context="http://www.springframework.org/schema/context"
 5        xsi:schemaLocation="http://www.springframework.org/schema/beans
 6                     http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
 7 
 8 <!--开启注解扫描,扫描包下的所有的类，看哪个类上有注解，把类放到IOC容器中-->
 9     <!--<bean id="userService" class="zh.test.demo"></bean>-->
10     <!---->
11     <context:component-scan base-package="zh.test"/>
12 
13 </beans>

测试程序

　　创建一个junitdemo的Java类来测试

 1 package zh.test.demo;
 2 
 3 import org.springframework.beans.factory.annotation.Autowired;
 4 import org.springframework.beans.factory.annotation.Qualifier;
 5 import org.springframework.beans.factory.annotation.Value;
 6 import org.springframework.context.annotation.Scope;
 7 import org.springframework.stereotype.Component;
 8 
 9 import javax.annotation.Resource;
10 import javax.naming.Name;
11 
12 //@Component
13 //public class UserServiceImpl
14 //   相当于
15 //<bean id="userServiceImpl" class="zh.test.demo.UserServiceImpl"></bean>
16 
17 //@Component("us")
18 //含义：把当前的类存放到IOC容器中，默认的ID值是首字母小写的类名。
19 // 如果属性是value，而且只写了一个属性，那么value是可以省略不写的
20 
21 
22 //@Scope(value = "singleton")  默认是单例的，如果改成是多例的则换成prototype
23 @Component("us")
24 @Scope(value = "singleton")
25 public class UserServiceImpl implements UserService {
26 //    @Value("lebron") 给属性注入值，在使用这种方式给属性注入值得时候，那么就不用提供set方法也是可以的
27     @Value("lebron")
28     private String name;
29 
30 //    public void setName(String name) {
31 //        this.name = name;
32 //    }
33 
34     //@Autowired   按照类型注入  没有按照ID的方式注入（和ID没有关系）。
35     //@Qualifier(value = "UserDao")  注入的时候根据名字注入。和UserDaoImpl 上注入的名字要相同。
36     //如果使用@Resource(name = "UserDao") 这个方式注解，则这一个相当于上面那两个注解
37 //    @Autowired
38 //    @Qualifier(value = "UserDao")
39 
40     @Resource(name = "UserDao")
41     private UserDaoService userDaoService;
42 
43 
44     public void setUserDaoService(UserDaoService userDaoService) {
45         this.userDaoService = userDaoService;
46     }
47 
48     public void save() {
49         userDaoService.save();
50         System.out.println("注解的方式。。。"+name);
51     }
52 }

测试纯注解的方式，创建testdemo1.java 文件。

 1 package zh.test;
 2 
 3 import org.junit.Test;
 4 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 5 import zh.test.demo1.AnnotationProperties;
 6 import zh.test.demo1.DeptService;
 7 
 8 public class testdemo1 {
 9 
10     @Test
11     public void test1()
12     {
13         //创建工厂，加载配置类文件。
14         AnnotationConfigApplicationContext factory = new AnnotationConfigApplicationContext(AnnotationProperties.class);
15         DeptService deptService = (DeptService) factory.getBean("deptService");
16         deptService.find();
17     }
18 }

分享之路，欢迎交流。。。