本节内容：
Spring介绍
Spring搭建
Spring概念
Spring配置讲解
使用注解配置Spring
一、Spring介绍
1. 什么是Spring
Spring是一个开源框架,Spring是于2003 年兴起的一个轻量级的Java 开发框架，由 RodJohnson 在其著作 Expert One-On-One J2EE Development and Design 中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。Spring 使用基本的 JavaBean 来完成以前只可能由 EJB 完成的事情。然而，Spring 的用途不仅限于服务器端的开发，去开发android也可以。从简单性、可测试性和松耦合的角度而言，任何 Java 应用都可以从 Spring 中受益。Spring 的核心是控制反转 (IoC)和面向切面(AOP)。简单来说，Spring 是一个分层的 JavaSE/EEfull-stack(一站式) 轻量级 开源框架。
JavaEE开发分成三层结构：
WEB层
业务层
持久层
三层架构中Spring的位置：
Spring是一个大的容器，其中装了很多对象，之前三层架构在运行时，都需要自己来创建对象，比如在web层中需要使用service层中的，需要new。当使用了Spring之后，Spring中已经存好了项目中需要的对象。也就是在三层中，需要对象时不需要在写new了，而是跟Spring要这个对象。
Spring是一站式框架：纯Spring开发一个项目是完全没问题的。正是因为Spring框架性质是属于容器性质的（比如Spring之所以能处理请求，是因为容器中装了能处理请求的框架，所以它在web层能处理请求），容器中装什么对象，就有什么功能。所以可以一站式。
WEB层：Spring MVC
业务层：Bean管理：（IoC）
持久层：Spring的JDBC模板。ORM模板用于整合其他的持久层框架。
2. 为什么要学习Spring
方便解耦，简化开发
Spring 就是一个大工厂，可以将所有对象创建和依赖关系维护，交给 Spring 管理
AOP 编程的支持
Spring 提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能
声明式事务的支持
只需要通过配置就可以完成对事务的管理,而无需手动编程
方便程序的测试
Spring 对 Junit4 支持,可以通过注解方便的测试 Spring 程序
方便集成各种优秀框架
Spring 不排斥各种优秀的开源框架,其内部提供了对各种优秀框架(如:Struts、Hibernate、MyBatis、Quartz 等)的直接支持 降低 JavaEE API 的使用难度
Spring 对 JavaEE 开发中非常难用的一些 API(JDBC、JavaMail、远程调用等)，都提供了封装，使这些 API 应用难度大大降低。
3. Spring 的版本
Spring 3.X 和 Spring4.X
Spring 3.0.2版本：将市面上常见的、支持整合进来的工具类全部进行了收录，这个包里面有很多很多jar包。但是这是Spring坚持“做好事”的最后一个版本，没有任何回报。
以Spring 4.2.4为例：解压压缩包spring-framework-4.2.4.RELEASE-dist.zip
docs是Spring的文档，API和开发规范
lib下是Spring的jar包和源码包
schema下是Spring当中的约束文件
lib目录下的包看起来很多，其实是3个一组：
二、Spring搭建示例
1. 下载导包
Spring官网：http://spring.io/
下载地址: http://repo.springsource.org/libs-release-local/org/springframework/spring
解压好的lib下的jar包不会都用，针对需要选择相应的jar包。
2. 创建web项目，引入Spring的开发包
在 web/WEB_INF/ 目录下创建一个lib目录，把下图中的4个jar包放进lib目录下。
Spring本身也是支持日志的，市面上已经有非常成熟的日志包了，Spring日志系统使用的是Apache开发出来的日志包。所以还需要导入Apache的日志方面的jar包，这部分jar包不在Spring解压后的lib下，得去Apache官方网站下载。把com.springsource.org.apache.commons.logging-1.1.1.jar和com.springsource.org.apache.log4j-1.2.15.jar复制到lib目录下。新版本的Spring应该不需要导入com.springsource.org.apache.log4j-1.2.15.jar，导了也不会错。
点击 File --> Project Structure，进入 Project Structure窗口，点击 Modules --> 选中项目 --> 切换到 Dependencies 选项卡 --> 点击下面的“+”，选择 “JARs or directories...”，选择创建的lib目录。
3. 创建包，编写一个类文件
User.java
package com.wisedu.springDemo;
/**
* Created by jkzhao on 12/7/17.
*/
public class User {
private String name;
private Integer age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
4. 书写Spring的配置文件，注册对象到Spring容器
对象和框架交流，通过配置文件交流。
Spring的配置文件存放位置任意，放在src目录下。名字也是任意，但是建议叫applicationContext.xml。
选中src，右键选择New --> XML Configuration File --> Spring Config，输入名字applicationContext，点击OK。
默认生成的文件约束是写了一些的。在我们这个例子中，上面默认生成的约束就够用了。
下面开始配置约束，这个user对象要交给Spring容器来管理。
applicationContext.xml
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">
5. 代码测试
在 src 下创建一个包：com.wisedu.test，然后创建一个类文件testSpringDemo.java：
package com.wisedu.test;
import org.junit.Test;
import org.springframework.context.ApplicationContext; //这是一个接口，创建容器对象时需要找其实现类
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.wisedu.springDemo.User;
/**
* Created by jkzhao on 12/7/17.
*/
public class testSpringDemo {
@Test
public void test1(){
//1.创建容器对象（创建Spring的工厂类）
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml"); //ClassPathXmlApplicationContext(从类路径下加载xml的Application容器)是org.springframework.context.ApplicationContext的实现类
//2.向容器"要"User对象（通过工厂解析XML获取Bean实例）
User user = (User)ac.getBean("user");
//3.打印User对象
System.out.print(user);
}
}
运行该方法，然后可以发现打印出值了，也就是获取到了User对象。
【注意】：上面在test1方法中，创建容器是使用 ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml"); 来创建的，每个项目中只有一个applicationContext对象，不是每个方法中都要创建一下。如何保证只创建一个？
之前学过一个ServletContext域对象，它在一个项目中只有一份，随着程序的启动而创建，随着程序的停止而销毁。这就用到了Listener。监听器中有8个监听器，使用其中一个监听器：ServletContext域创建和销毁的Listener。这样当ServletContext创建时我们可以创建applicationContext对象，当ServletContext销毁时，我们可以销毁applicationContext对象。这样applicationContext就和ServletContext“共生死了”。使用这个监听器还有一个好处，在监听器中可以非常方便地获得事件源，也就意味着我们可以获得ServletContext对象，这个容器被放进了ServletContext域对象中，说通俗点，就是被放进了application域中。Spring已经把这个监听器写好了，我们只需要在web.xml中配置下就可以了。当然还需要导入一个包：spring-web-4.2.4.RELEASE.jar
前面在讲到Spring容器时说道，Spring的配置文件位置任意，Spring配置文件名字任意，所以这意味着还需要在web.xml中指明该配置文件的位置及名称。
classpath*:/applicationContext.xml
接着写java代码从application域中获取容器。但是application域中存放东西是键值对存在的，我们得知道键才能取。Spring考虑到这种情况，准备了一个工具方法，把键封装在工具方法中了。
//1.这里以Struts2为例获取ServletContext对象
ServletContext sc = ServletActionContext.getServletContext();
//2.从sc中获得ac容器
WebApplicationContext ac = WebApplicationContextUtils.getWebApplicationContext(sc);
//3.从容器中获得需要的对象
...
三、Spring概念
1. IOC思想和DI技术
（1）IOC (Inverse Of Control)：控制反转，将我们创建对象的方式反转了。
以前对象的创建是由开发人员自己维护，包括依赖关系也是自己注入。使用了Spring之后，对象的创建以及依赖关系可以由Spring完成创建以及注入。
（2）DI(Dependency Injection)：依赖注入。将必须的属性注入到对象当中，是实现IOC思想的必要条件。
需要有 IOC 的环境，Spring 创建这个类的过程中，Spring 将类的依赖的属性设置进去。
注入方式：
set方法注入
构造方法注入
字段注入：不建议。
注入类型：
值类型注入：8大基本数据类型。比如上面示例中的User对象，它里面有name和age两个属性，现在我们希望User对象创建出来后，name="Tom"，age=18。这个"Tom"和18可以在配置文件中配置，这样Spring会把我们配置的值自动交给属性。
引用类型注入：将依赖的对象注入
所以实现IOC思想需要DI支持，DI对IOC提供了技术上的支撑。
2. Spring中的工厂(容器)
（1）ApplicationContext
ApplicationContext接口有两个实现类：
ClassPathXmlApplicationContext :加载类路径下 Spring 的配置文件
FileSystemXmlApplicationContext :从绝对路径上加载本地磁盘下 Spring 的配置文件，基本用不着。
（2）BeanFactory(过时)
BeanFactory是个接口，是Spring框架在初创时创建的第一个接口。像这种初创的接口，功能一般是很少的，针对原始接口的实现类功能较为单一。下面是幅继承关系图。
（3）BeanFactory 和 ApplicationContext 的区别
BeanFactory接口的实现类的容器特点是：每次在获得对象时才会创建对象。比如上面示例中的代码，
User user = (User)ac.getBean("user"); //只有在获取对象时才会创建对象
而ApplicationContext接口实现类的容器特点是：在加载applicationContext.xml（容器启动）时候就会创建容器中配置的所有对象。除此以外，提供更多功能。
总结：在web开发中，使用applicationContext，在硬件资源匮乏的环境使用BeanFactory。
四、Spring配置详解
1. Bean元素的配置
Bean元素：凡是交给Spring容器管理的对象都是由Bean来描述。
name属性：给被管理的对象起个名字。获得对象时根据该名称获得对象
class属性：被管理对象的完整类名
id属性：早年使用的，功能与name属性一模一样，id的规矩：名称不能重复，不能使用特殊字符。所以加了name属性，可以使用特殊字符，名称也可以重复，但是不推荐名称重复。
结论：尽量使用name属性。
2. Spring生成Bean的三种方式（三种对象创建方式）
对象的创建必须经过类的构造函数。
（1）空参构造创建 --最重要
在上面示例中的User对象中加一个无参构造函数
重新创建一个包，把applicationContext.xml复制进该包中，把测试类testSpringDemo.java复制进该包中，并修改该文件中applicationContext.xml的位置。
具体代码如下：
User.java
package com.wisedu.springDemo;
/**
* Created by jkzhao on 12/7/17.
*/
public class User {
private String name;
private Integer age;
public User() {
System.out.println("User对象空构造方法");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Car getCar() {
return car;
}
public void setCar(Car car) {
this.car = car;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
applicationContext.xml
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">
testSpringDemo.java
package com.wisedu.createObject;
import com.wisedu.springDemo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
* Created by jkzhao on 12/7/17.
*/
public class testSpringDemo {
@Test
//创建方式1：空参构造创建对象
public void test1(){
//1.创建容器对象（创建Spring的工厂类）
ApplicationContext ac = new ClassPathXmlApplicationContext("com/wisedu/createObject/applicationContext.xml"); //ClassPathXmlApplicationContext(从类路径下加载xml的Application容器)是org.springframework.context.ApplicationContext的实现类
//2.向容器"要"User对象（通过工厂解析XML获取Bean实例）
User user = (User)ac.getBean("user");
//3.打印User对象
System.out.print(user); //true
}
}
运行结果：
（2）静态工厂方式 --了解
写一个类，在类中建一个方法，该方法中把user创建出来。调用该方法创建user，然后交给Spring容器来管理，这样就不是Spring来创建对象了，我们希望Spring调用这个方法创建对象
UserFactory.java
package com.wisedu.createObject;
import com.wisedu.springDemo.User;
/**
* Created by jkzhao on 12/8/17.
*/
public class UserFactory {
//在该方法中手动把user创建出来。调用该方法创建user，然后交给Spring容器来管理，这样就不是Spring来创建对象了，我们希望Spring调用这个方法创建对象，如何配置呢
public static User createUser(){
System.out.println("静态工厂创建User");
return new User();
}
}
applicationContext.xml
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">
testSpringDemo.java
package com.wisedu.createObject;
import com.wisedu.springDemo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
* Created by jkzhao on 12/7/17.
*/
public class testSpringDemo {
@Test
//创建方式1：空参构造创建对象
public void test1(){
//1.创建容器对象（创建Spring的工厂类）
ApplicationContext ac = new ClassPathXmlApplicationContext("com/wisedu/createObject/applicationContext.xml"); //ClassPathXmlApplicationContext(从类路径下加载xml的Application容器)是org.springframework.context.ApplicationContext的实现类
//2.向容器"要"User对象（通过工厂解析XML获取Bean实例）
User user = (User)ac.getBean("user");
//3.打印User对象
System.out.print(user); //true
}
@Test
//创建方式2：静态工厂创建对象
public void test2(){
//1.创建容器对象（创建Spring的工厂类）
ApplicationContext ac = new ClassPathXmlApplicationContext("com/wisedu/createObject/applicationContext.xml"); //ClassPathXmlApplicationContext(从类路径下加载xml的Application容器)是org.springframework.context.ApplicationContext的实现类
//2.向容器"要"User对象（通过工厂解析XML获取Bean实例）
User user = (User)ac.getBean("user2");
//3.打印User对象
System.out.print(user);
}
}
（3）实例工厂方式 --了解
public User createUser2(){
System.out.println("实例工厂创建User");
return new User();
}
applicationContext.xml:
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">
测试方法：
@Test
//创建方式3：实例工厂创建对象
public void test3(){
//1.创建容器对象（创建Spring的工厂类）
ApplicationContext ac = new ClassPathXmlApplicationContext("com/wisedu/createObject/applicationContext.xml"); //ClassPathXmlApplicationContext(从类路径下加载xml的Application容器)是org.springframework.context.ApplicationContext的实现类
//2.向容器"要"User对象（通过工厂解析XML获取Bean实例）
User user = (User)ac.getBean("user3");
//3.打印User对象
System.out.print(user);
}
3. bean元素的scope属性
scope属性是在bean元素上加的。
singleton :默认值，单例对象。被标识为单例的对象在Spring容器中只会存在一份实例。
prototype :多例的。被标识为多例的对象每次在获得时才会创建，并且每次创建都是新的对象。单例对象是在容器启动时就创建了。
request :WEB 项目中，Spring 创建一个 Bean 的对象，将对象存入到 request 域中。对象与request生命周期一致。 --基本不用
session :WEB 项目中，Spring 创建一个 Bean 的对象，将对象存入到 session 域中。对象与session生命周期一致。 --基本不用
globalSession :WEB 项目中，应用在 Porlet 环境。如果没有 Porlet 环境那么 globalSession 相当于 session。 --基本不用
在未来的开发中，绝大多数scope的取值都是使用默认值，但是Spring与Struts2整合时，action对象要交给Spring来管理，action这个bean得配置为prototype。因为Struts2从架构上来说，每次请求都会创建一个新的action。
4. bean元素的生命周期属性 --了解
通过配置
【注意】：销毁方法想要执行，需要是单例创建的 Bean，而且在工厂关闭的时候，Bean 才会被销毁.
5. Spring的分模块配置文件
实际开发中，可能会把Sprign的配置写到多个文件中，这时可以在Spring主配置文件中引入其他Spring配置文件。
6. Spring中的Bean的属性注入
（1）set方法注入属性 --最重要
applicationContext.xml
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">
User.java
package com.wisedu.springDemo;
/**
* Created by jkzhao on 12/7/17.
*/
public class User {
private String name;
private Integer age;
private Car car;
public User() {
System.out.println("User对象空构造方法");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Car getCar() {
return car;
}
public void setCar(Car car) {
this.car = car;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
", car=" + car +
'}';
}
}
Car.java
package com.wisedu.springDemo;
/**
* Created by jkzhao on 12/8/17.
*/
public class Car {
private String name;
private String color;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
@Override
public String toString() {
return "Car{" +
"name='" + name + '\'' +
", color='" + color + '\'' +
'}';
}
}
测试方法：
@Test
public void test1(){
//1.创建容器对象（创建Spring的工厂类）
ApplicationContext ac = new ClassPathXmlApplicationContext("com/wisedu/injection/applicationContext.xml"); //ClassPathXmlApplicationContext(从类路径下加载xml的Application容器)是org.springframework.context.ApplicationContext的实现类
//2.向容器"要"User对象（通过工厂解析XML获取Bean实例）
User user = (User)ac.getBean("user");
//3.打印User对象
System.out.println(user);
}
运行结果：
（2）构造函数注入属性 --重要
前提：类中得有带有参数的构造函数。
在上面的User.java中添加拥有两个参数的构造方法：
public User(String name, Car car) {
System.out.println("User(String name, Car car)");
this.name = name;
this.car = car;
}
在applicationContext.xml文件中添加配置：
测试方法：
@Test
public void test2(){
//1.创建容器对象（创建Spring的工厂类）
ApplicationContext ac = new ClassPathXmlApplicationContext("com/wisedu/injection/applicationContext.xml"); //ClassPathXmlApplicationContext(从类路径下加载xml的Application容器)是org.springframework.context.ApplicationContext的实现类
//2.向容器"要"User对象（通过工厂解析XML获取Bean实例）
User user = (User)ac.getBean("user2");
//3.打印User对象
System.out.println(user);
}
运行结果：
但是假设我们User类中有多个构造方法，里面参数位置不一样，代表实际业务中不同的逻辑，比如：
public User(String name, Car car) {
System.out.println("User(String name, Car car)");
this.name = name;
this.car = car;
}
public User(Car car, String name) {
System.out.println("User(Car car, String name)");
this.name = name;
this.car = car;
}
我们如何在配置文件中指定走哪个构造方法呢？需要index属性，index=0表示该属性是构造方法中的第一个参数，index=1表示该属性是构造方法中的第二个参数。
还有一种情况，构造方法是这样的，代表另一种业务。
public User(String name, Car car) { //业务1
System.out.println("User(String name, Car car)");
this.name = name;
this.car = car;
}
public User(Car car, String name) { //业务2
System.out.println("User(Car car, String name)");
this.name = name;
this.car = car;
}
public User(Integer name, Car car) { //业务3
System.out.println("User(Integer name, Car car)");
this.name = name + "";
this.car = car;
}
配置：
（3）p名称空间注入属性 --了解
需要引入p名称空间。
（4）spel注入属性 --了解
（5）复杂类型的注入
前面讲的注入类型要么就是值，要么就是对象。如果遇到数组、Map、List或properties，该如何注入？直接使用set方式注入这几种复杂类型。
CollectionBean.java
package com.wisedu.injection;
import java.util.*;
/**
* Created by jkzhao on 12/8/17.
*/
public class CollectionBean {
private Object[] arr;
private List list; //list和set的注入方式一样
private Map map;
private Properties prop; //Properties就是个map
public Object[] getArr() {
return arr;
}
public void setArr(Object[] arr) {
this.arr = arr;
}
public List getList() {
return list;
}
public void setList(List list) {
this.list = list;
}
public Map getMap() {
return map;
}
public void setMap(Map map) {
this.map = map;
}
public Properties getProp() {
return prop;
}
public void setProp(Properties prop) {
this.prop = prop;
}
@Override
public String toString() {
return "CollectionBean{" +
"arr=" + Arrays.toString(arr) +
", list=" + list +
", map=" + map +
", prop=" + prop +
'}';
}
}
applicationContext.xml
测试方法：
@Test
public void test5(){
//1.创建容器对象（创建Spring的工厂类）
ApplicationContext ac = new ClassPathXmlApplicationContext("com/wisedu/injection/applicationContext.xml"); //ClassPathXmlApplicationContext(从类路径下加载xml的Application容器)是org.springframework.context.ApplicationContext的实现类
//2.向容器"要"User对象（通过工厂解析XML获取Bean实例）
CollectionBean cb = (CollectionBean)ac.getBean("cb");
//3.打印User对象
System.out.println(cb);
}
五、使用注解配置Spring（代替xml配置）
Hibernate、Struts2、Spring都支持注解方式配置。注解是JDK1.5开始引入的，这三大框架都是在JDK1.5以前出来的。但是在开发中很少使用注解来配置Hibernate和Struts2。
1. 注解示例
新建一个包，com.wisedu.annotation。
（1）Spring 4.2.4使用注解还需要导入一个包
spring-aop-4.2.4.RELEASE.jar 老版本不需要。
（2）为主配置文件引入新的命名空间（约束）
在默认生成的applicationContext.xml文件中添加配置
xmlns:context="http://www.springframework.org/schema/context"
在 xsi:schemaLocation= 后面添加如下配置：
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd
（3）在主配置文件中开启使用注解代理配置文件（打开使用注解的开发）
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
（4）在类中使用注解完成配置
User.java
package com.wisedu.annotation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.annotation.Resource;
/**
* Created by jkzhao on 12/7/17.
*/
//@Component //组件
//
@Component("user")
public class User {
private String name;
private Integer age;
private Car car;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Car getCar() {
return car;
}
public void setCar(Car car) {
this.car = car;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
", car=" + car +
'}';
}
}
其中，@Component()是Spring在注册Bean的一个早期注解，后来又出现了这么几个注解：@Service()、@Controller、@Repository()
一开始只有@Component()，但是后来使用者向Spring反馈，在注册项目中所有对象的时候，都有这同一个注解，这样很难区分这个对象属于哪一层，所以又增加3个注解。这3个注解和@Component()没有任何区别，但是这3个注解通过看名字，就知道注册的对象属于哪一层。
@Service()：注册service层对象
@Controller：注册web层对象
@Repository()：注册Dao层对象
（5）测试
test.java
package com.wisedu.annotation;
import com.wisedu.annotation.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import javax.annotation.Resource;
/**
* Created by jkzhao on 12/7/17.
*/
@RunWith(SpringJUnit4ClassRunner.class) //帮我们创建容器
@ContextConfiguration("classpath:com/wisedu/annotation/applicationContext.xml") //指定创建容器时使用哪个文件
//@ContextConfiguration(locations = "classpath:com/wisedu/annotation/applicationContext.xml")
public class test {
//将名为user的对象注入到u变量中
@Resource(name = "user")
private User u;
@Test
public void test3(){
System.out.print(u);
}
@Test
public void test1(){
//1.创建容器对象（创建Spring的工厂类）
ApplicationContext ac = new ClassPathXmlApplicationContext("com/wisedu/annotation/applicationContext.xml"); //ClassPathXmlApplicationContext(从类路径下加载xml的Application容器)是org.springframework.context.ApplicationContext的实现类
//2.向容器"要"User对象（通过工厂解析XML获取Bean实例）
User user = (User)ac.getBean("user");
//3.打印User对象
System.out.print(user);
}
}
2. 注解形式下对象的作用范围
@Scope(scopeName = "prototype") //默认是单例的
package com.wisedu.annotation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.annotation.Resource;
/**
* Created by jkzhao on 12/7/17.
*/
//@Component //组件
//
@Component("user")
@Scope(scopeName = "prototype") //默认是单例的
public class User {
private String name;
private Integer age;
private Car car;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Car getCar() {
return car;
}
public void setCar(Car car) {
this.car = car;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
", car=" + car +
'}';
}
}
测试方法：
@Test
public void test2(){
//1.创建容器对象（创建Spring的工厂类）
ApplicationContext ac = new ClassPathXmlApplicationContext("com/wisedu/annotation/applicationContext.xml"); //ClassPathXmlApplicationContext(从类路径下加载xml的Application容器)是org.springframework.context.ApplicationContext的实现类
//2.向容器"要"User对象（通过工厂解析XML获取Bean实例）
User user = (User)ac.getBean("user");
User user2 = (User)ac.getBean("user");
User user3 = (User)ac.getBean("user");
//3.打印User对象
System.out.print(user==user2);
}
3. 属性的注入
（1）值赋值
在成员变量上面加注释@Value()，或者把这个注释放到这个成员变量的set方法上。
User.java
package com.wisedu.annotation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.annotation.Resource;
/**
* Created by jkzhao on 12/7/17.
*/
//@Component //组件
//
@Component("user")
@Scope(scopeName = "prototype") //默认是单例的
public class User {
@Value("tom")
private String name;
private Integer age;
private Car car;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
@Value(value = "18")
public void setAge(Integer age) {
this.age = age;
}
public Car getCar() {
return car;
}
public void setCar(Car car) {
this.car = car;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
", car=" + car +
'}';
}
}
这两种的区别：
加在成员变量上，Spring在给这个对象赋值的时候，通过反射的Field赋值。而放在成员的set方法上，走的set方法赋值的（推荐使用）。
虽然结果是一样的，但是放在成员变量上破坏了对象的封装性。本来这个属性私有，就是为了封装，提供get和set方法操作，加在成员变量上就是Spring直接去操作对象了。
所以在set方法上加是推荐上，但是在成员变量上加很清晰，方便，在set方法上加很别扭，这就很矛盾。实际使用上两种都可以。
另外，上面的示例中：@Value(value="18")和@Value("18")是一样的，这是一个结论（直接记住）：如果注解中的属性如果只有一个需要赋值，并且这个属性名是value的话，写的时候可以忽略属性的键，也就是忽略"value"。包括前面写的@Component("user")，没写键的，都是给value赋值的。
（2）引用类型赋值
首先你必须把赋值的对象给注册到容器中，比如上面示例中的car。
多种方式实现对象赋值：
第一种：
User.java代码片段：
@Component("user")
@Scope(scopeName = "prototype") //默认是单例的
public class User {
@Value("tom")
private String name;
private Integer age;
@Autowired //自动装配。根据类型来检测扫描容器当中符合这个属性类型的对象，如果检测到了，找到这个对象，赋值给这个属性
@Qualifier("car2")
private Car car; ...
其中，Car.java代码片段：
@Component("car")
public class Car {
@Value("兰博基尼")
private String name;
@Value("屎黄色")
private String color;
...
运行结果：
这种注入引用类型有个缺陷，假如我把这个Car注册到好几遍这个容器当中，假如在容器中有3辆车。比如这个在applicationContext.xml中在配置辆车。
这样Spring中就有两辆车了。这样我们无法控制具体将哪辆车注入Car属性。这个时候我们可以给 @Autowired 加个辅助注解，
@Autowired
@Qualifier("car2")
private Car car;
再次运行：
第二种：当引用对象有多个的时候，需要把该对象注入给某属性时，不建议使用上面两个注解，有个注解不是自动装配，直接“指名道姓”，叫@Resource(name = "car2")
//@Autowired //自动装配。根据类型来检测扫描容器当中符合这个属性类型的对象，如果检测到了，找到这个对象，赋值给这个属性
//@Qualifier("car2")
@Resource(name = "car2") //手动注入，指定注入哪个名称的对象
private Car car;
4. 初始化和销毁方法
User.java代码片段：
@PostConstruct //在对象被创建后调用，类似于之前学习的init-method
public void init(){
System.out.println("初始化方法");
}
@PreDestroy //在对象销毁之前调用，类似于之前学习的destory-method
public void destory(){
System.out.println("销毁方法");
}
【注意】：如果想执行销毁方法，必须将User对象改为单例的。
Spring的Bean管理方式的比较：
XML和注解：
XML：结构清晰
注解：开发方便(属性注入)
实际开发中还有一种 XML 和注解整合开发：
Bean 有 XML 配置，但是使用的属性使用注解注入