本篇讲的内容主要是基于Spring v2.5的注解来完成bean的定义
之前都是使用纯配置的方式来定义的bean

前言

XML配置解耦，而注解是简化开发

1. Spring v2.5 注解开发定义bean

之前都是使用纯配置的方式，在Spring Config中通过<bean id="xxx" class="xxx" />来定义的bean，从此处开始将根据注解开发定义bean

第一步：在需要定义的类上写上注解@Component

这里有两种写的形式：
@Component
或者是给其定义名称
@Component("bookDao")
通过第一种形式，就通过在getBean()方法中写类型来获得bean
通过第二种形式，就通过在getBean()方法中写名称来获得bean

package com.example.demo.dao.impl;import com.example.demo.dao.BookDao;
import org.springframework.stereotype.Component;@Component
// @Component("bookDao")
public class BookDaoImpl implements BookDao {@Overridepublic void save() {System.out.println("Book Dao Save...");}
}

第二步：在Spring Config中定义扫描包

注意，这里也要开启命名空间
然后通过<context:component-scan base-package="...." />进行定义扫描的包，这里就是扫描com.example.demo.dao下边的包，修改这个包为com.example.demo也是可以的

<?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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsd"><context:component-scan base-package="com.example.demo.dao" /></beans>

第三步：主方法中测试

package com.example.demo;import com.example.demo.dao.BookDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;public class DemoApplication {public static void main(String[] args) {ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");// 第一种定义形式写法，定义@Component写BookDao bookDao = ctx.getBean(BookDao.class);System.out.println(bookDao);// 第二种定义形式写法，定义@Component("bookDao")写BookDao bookDao1 = (BookDao) ctx.getBean("bookDao");System.out.println(bookDao1);}
}

结果均为

com.example.demo.dao.impl.BookDaoImpl@3a52dba3

基于@Component的衍生注解

@Controller：表现层定义bean
@Service：业务层定义bean
@Repository：数据层定义bean
比如，在BookServiceImpl类上就使用@Service进行定义；在BookDaoImpl类上就使用@Repository进行定义，加括号的规则@Component类似，调用的方式也和原本的类似

2. Spring v3.0 纯注解开发

既然是纯注解开发，就需要删除之前冗余的这个配置文件，纯注解开发将配置的xml文件转换为了一个配置类

第一步：创建配置类

配置类写法为，实际上就是用两个注解来替代了原本配置文件中的内容：

package com.example.demo.config;import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;@Configuration
@ComponentScan("com.example.demo")
public class SpringConfig {
}

配置文件中的内容分别被配置类中的内容替代，如下：

假如想扫描多个包，使用{}来写即可，如：@ComponentScan({"com.example.demo.dao", "com.example.demo.service"})

第二步：导入配置类

将原本的加载配置文件的ClassPathXmlApplicationContext换成了加载配置类AnnotationConfigApplicationContext，里面的参数是注解类名称.class，即读取这个注解类，剩下getBean的操作和原来一样。

package com.example.demo;import com.example.demo.config.SpringConfig;
import com.example.demo.dao.BookDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;public class DemoApplication {public static void main(String[] args) {ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);BookDao bookDao = ctx.getBean(BookDao.class);System.out.println(bookDao);}
}

3. Bean的作用范围(单例/多例)与生命周期

Bean的作用范围

之前配置Bean的作用范围是在配置文件里通过指定scope属性定义的：
scope="singleton/prototype"

<bean id="bookDao" name="dao" class="com.example.demo231116.dao.impl.BookDaoImpl" scope="prototype" />

因为Bean默认是单例模式，如果我们想要修改成多例模式，就在类上加@Scope注解，括号的内容写prototype为多例，singleton为单例

package com.example.demo.dao.impl;import com.example.demo.dao.BookDao;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;@Repository
@Scope("prototype")
public class BookDaoImpl implements BookDao {@Overridepublic void save() {System.out.println("Book Dao Save...");}
}

Bean的生命周期

之前提到，Bean的生命周期其实就是我们可以定义在Bean加载的时候初始化一些资源，在销毁前销毁一些资源，在配置文件中写初始化和销毁是通过init-method和destroy-method实现的：

<bean id="bookDaoCycle" class="com.example.demo231116.dao.impl.BookDaoImpl" init-method="init" destroy-method="destroy" />

在注解开发中，我们只需要在类中写好初始化和销毁方法，并分别加上PostConstruct（注解后执行init方法）和PreDestroy（销毁前执行destroy方法）两个注解，注意，初始化和销毁方法的方法名是任意的：

package com.example.demo.dao.impl;import com.example.demo.dao.BookDao;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;@Repository
//@Scope("prototype")
public class BookDaoImpl implements BookDao {@Overridepublic void save() {System.out.println("Book Dao Save...");}@PostConstructpublic void init(){System.out.println("init...");}@PreDestroypublic void destroy(){System.out.println("destroy");}}

注意，如果提示没找到注解的话需要在pom.xml中导入坐标：

<dependency><groupId>javax.annotation</groupId><artifactId>javax.annotation-api</artifactId><version>1.2</version>
</dependency>

然后再执行主方法：

package com.example.demo;import com.example.demo.config.SpringConfig;
import com.example.demo.dao.BookDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;public class DemoApplication {public static void main(String[] args) {ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);BookDao bookDao = ctx.getBean(BookDao.class);System.out.println(bookDao);}
}

执行的结果为：

init...
com.example.demo.dao.impl.BookDaoImpl@7eac9008

没有调用Destroy方法的原因是没有关闭IoC容器/注册关闭钩子，只需要像之前一样在程序结束前使用ctx.close()或通过ctx.registerShutdownHook()来注册关闭钩子
（该方法注意不能使用ApplicationContext类，因为没有close()方法和registerShutdownHook()方法）

package com.example.demo;import com.example.demo.config.SpringConfig;
import com.example.demo.dao.BookDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;public class DemoApplication {public static void main(String[] args) {AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
//		方法二ctx.registerShutdownHook();BookDao bookDao = ctx.getBean(BookDao.class);System.out.println(bookDao);//		方法一ctx.close();}
}

注意：非单例模式不会执行destroy，因为多例模式下Spring不负责销毁。Spring默认是单例的，它只管单例的销毁而不管多例的销毁

4.依赖注入

引用类型注入

依赖注入使用自动装配的方式，这里阉割掉了配置文件中的Setter注入、构造注入等等一系列冗杂的方法，使用自动装配。

@Autowire属性默认按类型注入

这里注入很简单，只需要在属性上加上@Autowire注解，就能够实现自动装配，这里的自动装配是基于暴力反射实现的，也无需再BookDaoImpl中实现set方法

package com.example.demo.service.impl;import com.example.demo.dao.BookDao;
import com.example.demo.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;@Service
public class BookServiceImpl implements BookService {@AutowiredBookDao bookDao;@Overridepublic void save() {System.out.println("Book Service Save...");bookDao.save();}
}

假如我有两个类实现了BookDao.java这个类：BookDaoImpl和BookDaoImpl2，这时候再执行自动装配会报错，因为基于类型反射得到的类不唯一

按类型注入反射结果不唯一，按名注入

针对这种不唯一的情况，给两个类的@Repository注解后加名字，BookDaoImpl和BookDaoImpl2分别为@Repository("bookDao")和@Repository("bookDao2")：

package com.example.demo.dao.impl;import com.example.demo.dao.BookDao;
import org.springframework.stereotype.Repository;@Repository("bookDao")
public class BookDaoImpl implements BookDao {@Overridepublic void save() {System.out.println("Book Dao Save...");}
}

package com.example.demo.dao.impl;import com.example.demo.dao.BookDao;
import org.springframework.stereotype.Repository;@Repository("bookDao2")
public class BookDaoImpl2 implements BookDao {@Overridepublic void save() {System.out.println("Book Dao Save...2");}
}

此时，假如我们在Service中的属性定义是

@Autowired
BookDao bookDao2;

则会注入对应BookDaoImpl2这个类，如果写的是bookDao1则会注入对应BookDaoImpl这个类
以上其实就是说明，Spring注解开发中，如果按类型注入不成功，就会按名注入，这些都是自动的，无需人为配置按类型注入/按名注入

按名注入的标准写法（少用）

事实上，按名注入更标准的方法是使用@Qualifier注解，这种注解还是要基于给BookDaoImpl和BookDaoImpl2都在@Repository后指定了名称的情况下进行的，标准写法如下：

package com.example.demo.service.impl;import com.example.demo.dao.BookDao;
import com.example.demo.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;@Service
public class BookServiceImpl implements BookService {@Autowired@Qualifier("bookDao2")BookDao bookDao;@Overridepublic void save() {System.out.println("Book Service Save...");bookDao.save();}
}

@Qualifier后指定你想让bookDao属性被哪个类注入，注意，该注解必须搭配@Autowired注解使用

简单类型注入

使用@Value属性完成注入，括号内写值

package com.example.demo.dao.impl;import com.example.demo.dao.BookDao;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Repository;@Repository
public class BookDaoImpl implements BookDao {@Value("namenamename!!!")String name;@Overridepublic void save() {System.out.println("Book Dao Save..." + this.name);}
}

就这样的方法，可能会有疑问，这样写和String name = "namenamename!!!"的区别是什么？
不一样的地方在于：你注解里面的这个字符串，可能来自于外部（比如来自于外部的properties文件）

引入外部的properties文件

假如在Resource下有jdbc.properties文件，有内容：

name=namenamename!!!

那么我们需要在配置类中加载这个文件，加上注解@PropertySource，括号内是文件名：

package com.example.demo.config;import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;@Configuration
@ComponentScan("com.example.demo")
@PropertySource("jdbc.properties")
public class SpringConfig {
}

然后在值名称上写使用${}引用即可：

package com.example.demo.dao.impl;import com.example.demo.dao.BookDao;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Repository;@Repository
public class BookDaoImpl implements BookDao {@Value("${name}")String name;@Overridepublic void save() {System.out.println("Book Dao Save..." + this.name);}
}

假如想加载多个配置文件，使用{}来写即可，类似于@ComponentScan
但是注意：之前在配置文件里加载的时候支持使用通配符*，但这里完全不支持使用通配符！
但是加上@PropertySource("classpath:jdbc.properties")是可以的，只是不能使用通配符

5. 第三方Bean

此处以数据库连接为例，需要在pom.xml中导入坐标：

<dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.1.16</version>
</dependency>

管理

在配置类中写一个方法，一般方法名为Bean的ID。然后new一个第三方对象，并返回。
在该方法上加上@Bean注解，表明该方法返回的是一个Bean

package com.example.demo.config;import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;import javax.sql.DataSource;@Configuration
@ComponentScan("com.example.demo")
public class SpringConfig {@Beanpublic DataSource dataSource(){DruidDataSource ds = new DruidDataSource();ds.setDriverClassName("com.mysql.jdbc.Driver");ds.setUrl("jdbc:mysql://localhost:3306/mysql");ds.setUsername("root");ds.setPassword("123456");return ds;}
}

这样写就可以在主方法里像平常一样获得Bean：

DataSource dataSource = ctx.getBean(DataSource.class);
System.out.println(dataSource);

但是将第三方的配置写在Spring的配置类中可能比较乱，所以我们给它新建一个文件JdbcConfig.java：

package com.example.demo.config;import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;import javax.sql.DataSource;@Configuration
public class JdbcConfig {@Beanpublic DataSource dataSource(){DruidDataSource ds = new DruidDataSource();ds.setDriverClassName("com.mysql.jdbc.Driver");ds.setUrl("jdbc:mysql://localhost:3306/mysql");ds.setUsername("root");ds.setPassword("123456");return ds;}
}

想要让这个文件被扫描到
第一种方法是在这个配置文件上加上注解@Configuration，然后在配置类中用@ComponentScan()扫描这个包：
@ComponentScan("com.example.config")
第二种方法（推荐使用）无需在文件上加注解@Configuration，而是直接在配置类中加上@Import注解，并在括号内写这个新的配置文件名.class：@Import(JdbcConfig.class)
完整代码如下：

package com.example.demo.config;import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;import javax.sql.DataSource;@Configuration
//@ComponentScan("com.example.demo.config")
@Import(JdbcConfig.class)
public class SpringConfig {@Beanpublic DataSource dataSource(){DruidDataSource ds = new DruidDataSource();ds.setDriverClassName("com.mysql.jdbc.Driver");ds.setUrl("jdbc:mysql://localhost:3306/mysql");ds.setUsername("root");ds.setPassword("123456");return ds;}
}

多个数据也使用数组模式

依赖注入

简单类型注入

只需要在类里面定义简单类型的成员变量，并在方法中使用成员变量即可，同样通过@Value()注解赋值

package com.example.demo.config;import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;import javax.sql.DataSource;@Configuration
public class JdbcConfig {@Value("com.mysql.jdbc.Driver")String driverClassName;@Value("jdbc:mysql://localhost:3306/mysql")String url;@Value("root")String usernmae;@Value("123456")String password;@Beanpublic DataSource dataSource(){DruidDataSource ds = new DruidDataSource();ds.setDriverClassName(driverClassName);ds.setUrl(url);ds.setUsername(usernmae);ds.setPassword(password);return ds;}
}

引用类型注入

假如要注入引用类型，需要在方法的参数里面写引用类型

package com.example.demo.config;import com.alibaba.druid.pool.DruidDataSource;
import com.example.demo.dao.BookDao;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;import javax.sql.DataSource;@Configuration
public class JdbcConfig {@Value("com.mysql.jdbc.Driver")String driverClassName;@Value("jdbc:mysql://localhost:3306/mysql")String url;@Value("root")String usernmae;@Value("123456")String password;@Beanpublic DataSource dataSource(BookDao bookDao){bookDao.save();DruidDataSource ds = new DruidDataSource();ds.setDriverClassName(driverClassName);ds.setUrl(url);ds.setUsername(usernmae);ds.setPassword(password);return ds;}
}

因为我们已经注解了这个dataSource是个Bean，所以对于方法里面的形参，Spring会自动到IoC里面查找对应的类进行注入

6. XML配置比对注解配置