1、Spring框架的诞生

1、BeanFactory 快速入门

1.1、BeanFactory完成了loC思想的实现：

1)导入Spring相关的依赖：

<dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.3.6</version></dependency></dependencies>

2)定义Uservice接口及其UserviceImpl实现类；

3)创建Bean的配置资源文件，文件名最好为：applicationContext.xml(规范)，将UserServicelmpl的信息配置到该xml中

<?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"><bean id="userService" class="cn.js.service.impl.UserServiceImpl"></bean>
</beans>

4)编写测试代码，创建BeanFactory，加载配置文件，获取UserService实例对象

1、通过工厂对象进行创建：

//1.创建工厂对象
DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();//2.创建一个读取器，用于读取Bean 的资源文件(.xml文件)
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);//3、读取配置文件给工厂
reader.loadBeanDefinitions("applicationContext.xml");//4、根据ID获取Bean实例对象
UserService userService = (UserService)beanFactory.getBean("userService");
System.out.println(userService);

2、直接从classpatch 路径去寻找配置文件创建资源对象(该方式已废弃了解即可)

//1、从ClassPath路径去寻找配置文件创建资源对象
Resource resource = new ClassPathResource("applicationContext.xml");//2、根据资源对象创建Bean工厂对象
BeanFactory beanFactory = new XmlBeanFactory(resource);//3、从SpringIoc容器中获取指定名称的对象
UserService userService = (UserService)beanFactory.getBean("userService");
System.out.println(userService);

上面使用BeanFactory完成了loC思想的实现，下面去实现以下DI依赖注入(setter方式):

1.2、使用BeanFactory通过setter方式去实现以下DI依赖注入：

1)定义UserDao接口及其UserDaolmpl实现类

public interface UserDao {}
public class UserDaoImpl implements UserDao {}

2)修改UserServicelmpl代码，添加一个setUserDao(UserDao userDao)用于接收注入的对象:

public class UserServiceImpl implements UserService {private UserDao userDao;public void setUserDao(UserDao userDao) {System.out.println("BeanFactory工厂调用该方法--》"+userDao);this.userDao=userDao;}
}

3)修改applicationContext.xml配置文件，定义UserService的中嵌入配置注入UserDao;

<?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"><bean id="userService" class="cn.js.service.impl.UserServiceImpl"><property name="userDao" ref="UserDao"></property></bean><bean id="UserDao" class="cn.js.dao.impl.UserDaoImpl"></bean>
</beans>

4)修改测试代码，获得UserService时，setUserService方法执行了注入操作。

  		//1.创建工厂对象DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();//2.创建一个读取器，用于读取Bean 的资源文件(.xml文件)XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);//3、读取配置文件给工厂reader.loadBeanDefinitions("applicationContext.xml");//4、根据ID获取Bean实例对象UserService userService = (UserService)beanFactory.getBean("userService");System.out.println(userService);UserDao userdao = (UserDao)beanFactory.getBean("UserDao");System.out.println(userdao);

打个断点：此时userDao，已经被注入

2、ApplicationContext 快速入门（重要）

ApplicationContext 称为Spring容器，内部封装了BeanFactory，比BeanFactory功能更丰富更强大，使用ApplicationContext 进行开发时，xml配置文件的名称习惯写成applicationContext.xml;

2.1、ApplicationContext实现Ioc思想

1）前三步和BeanFactry相同

5）读取核心配置文件获取实例化容器对象

//创建ApplicationContext，加载配置文件，实例化容器
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
//根据beanName获得容器中的Bean实例
UserService userService = (UserService) applicationContext.getBean("userService");
System.out.println(userService);

3、BeanFactory与ApplicationContext的关系:

1、 BeanFactory是Spring的早期接口，称为`Spring的Bean工厂`，ApplicationContext是后期更高级接口，称之为`Spring 容器`;  
2、 ApplicationContext在BeanFactory基础上对功能进行了扩展，例如: 监听功能、国际化功能等。BeanFactory的API更偏向底层，ApplicationContext的API大多数是对这些底层API的封装;
3、 Bean创建的主要逻辑和功能都被封装在BeanFactory中，ApplicationContext不仅继承了BeanFactory，而目ApplicationContext内部还维护着BeanFactorv的引用，所以，ApplicationContext与BeanFactorv既有继承关系，又有融合关系。
4、 Bean的初始化时机不同，原始BeanFactory是在首次调用getBean时才进行Bean的创建，而ApplicationContext则是配置文件加载，容器一创建就将Bean都实例化并初始化好

ApplicationContext除了继承了BeanFactory外，还继承了ApplicationEventPublisher (事件发布器)、ResouresPatternResolver (资源解析器)、MessageSource (消息资源)等。

但是ApplicationContext的核心功能还是BeanFactory。

4、BeanFactory的继承体系

BeanFactory的继承体系

BeanFactory是核心接口，项目运行过程中肯定有具体实现参与，这个具体实现就是DefaultListableBeanFactory而ApplicationContext内部维护的Beanfactory的实现类也是它

5、ApplicationContext的继承体系

1.ApplicationContext的继承体系

只在Spring基础环境下，即只导入spring-context坐标时，此时ApplicationContext的继承体系

2.只在Spring基础环境下，常用的三个ApplicationContext作用如下:

实现类	功能描述
ClassPathXmlApplicationContext	加载类路径下的xml配置的ApplicationContext
FileSystemXmlApplicationContext	加载磁盘路径下的xml配置的ApplicationContext
AnnotationConfigApplicationContext	加载注解配置类的ApplicationContext

3.在Spring的web环境下，常用的两个ApplicationContext作用如下

实现类	功能描述
XmIWebApplicationContext	Web环境下，加载类路径下的xml配置的ApplicationContext
AnnotationConfigWebApplicationContext	Web环境下，加载磁盘路径下的xml配置的ApplicationContext

2、基于XML的Spring应用

2.1、SpringBean的配置详解

Spring开发中主要是对Bean的配置，Bean的常用配置一览如下：

1）Bean的基础配置

例如:配置UserDaolmpl由Spring容器负责管理

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

此时存储到Spring容器(singleObjects单例池) 中的Bean的beanName是userDao，值是UserDaolmpl对象，可以根据beanName获取Bean实例

applicationContext.getBean("userDao");//beanName:进入Spring容器将 bean id="userDao" 这个ID转换成beanname

如果不配置id，则Spring会把当前Bean实例的全限定名作为beanName

applicationContext.getBean("com.js.dao.impl.UserDaoImpl") ;

2) Bean的别名配置

可以为当前Bean指定多个别名，根据别名也可以获得Bean对象

<bean id="userDao" "uname="aaa,bbb" class="com.js.dao.impl.UserDaoImpl"/>

此时多个名称都可以获得UserDaolmpl实例对象

applicationContext.getBean("userDao");
applicationContext.getBean("aaa");
applicationContext.getBean("bbb");

3) Bean的范围配置

默认情况下，单纯的Spring环境Bean的作用范围有两个: Singleton和Prototype

• singleton: 单例，默认值，Spring容器创建的时候，就会进行Bean的实例化，并存储到容器内部的单例池中每次getBean时都是从单例池中获取相同的Bean实例;

• prototype: 原型，Spring容器初始化时不会创建Bean实例，当调用getBean时才会实例化Bean，每次getBean都会创建一个新的Bean实例。

4) Bean的延迟加载

当lazy-init设置为true时为延迟加载，也就是当Spring容器创建的时候，不会立即创建Bean实例，等待用到时再创建Bean实例并存储到单例池中去，后续在使用该Bean直接从单例池获取即可，本质上该Bean还是单例的

< bean id="userDao"  class="com.js.dao.impl.UserDaoImpl"  ulazy-init="true"/>

5）Bean的初始化和销毁方法配置

Bean在被实例化后，可以执行指定的初始化方法完成一些初始化的操作，Bean在销毁之前也可以执行指定的销毁方法完成一些操作，初始化方法名称和销毁方法名称通过

< bean id="userDao"class="com.js.dao.impl.UserDaoImpln" init-method="init"  destroy-method="destroy" />

public class UserDaoImpl implements UserDao {public UserDaoImpl(){System.out.println("UserDaoImpl创建了...");}public void init(){System.out.printn("初始化方法...");}public void destroy(){ System.out.println("销毁方法...");}
}

public static void main(String[] args){ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext();UserService userService = (UserService) applicationContext.getBean("userDao")System.out.printIn(userService);//--------->这个地方是不会调用销毁方法的，如果没有调用close方法，Spring在执行这句输出语句后，就已经销毁了，还没有来得及调用销毁方法，所以我们要显示的关闭容器applicationContext.close() ;//关闭容器
} 

扩展: 除此之外，我们还可以通过实现 lnitializingean 接口，完成一些Bean的初始化操作，如下

public class UserDaoImpl implements UserDao, InitializingBean {public UserDaoImpl() {System.out.println("userDaoImpl创建了...");}public void init(){System.out.println("初始化方法...");}public void destroy(){System.out.println("销毁方法...");}//执行时机早于init-method配置的方法public void afterPropertiesSet() throws Exception {System.out.println("InitializingBean...");}
}

6）Bean的实例化配置

Bean的实例化配置:就是Spring 帮我们创建Bean

Spring的实例化方式主要如下两种：

• 构造方式实例化: 底层通过构造方法对Bean进行实例化；

  • 1.1 使用空构造器
  • 1.2 使用有参构造器

• 工厂方式实例化: 底层通过调用自定义的工厂方法对Bean进行实例化

构造方式实例化:

构造方式实例化Bean又分为无参构造方法实例化和有参构造方法实例化，Spring中配置的几乎都是无参构造该方式，此处不在述。下面讲解有参构造方法实例化Bean

//有参构造方法
public UserDaoImpl(String name){}

有参构造在实例化Bean时，需要参数的注入，通过标签，嵌入在标签内部提供构造参数，如下:

<bean id="userDao" class="com,js,dao implUserDaoImpl"><constructor-arg name="name" value="haohao"/>
</bean>

工厂方式实例化:

工厂方式实例化Bean，又分为如下三种:

• 静态工厂方法实例化Bean

• 实例工厂方法实例化Bean

• 实现FactoryBean规范延迟实例化Bean

1) 、静态工厂方法实例化Bean

静态工厂方法实例化Bean，其实就是定义一个工厂类，提供一个静态方法用于生产Bean实例，在将该工厂类及其 静态方法配置给Spring即可

//工厂类
public class UserDaoFactoryBean {
//非静态工厂方法
public static UserDao getUserDao(String name){
//可以在此编写一些其他逻辑代码
return new UserDaoImpl();}
}

<bean id="userDao" class="com.js.factory.UserDaoFactoryBean" factorymethod="getUserDao">
<constructor-arg name="name" value="haohao"/>
</bean>

解释：

1.Spring容器看到factorymethod：时知道，不是将"com.js.factory.UserDaoFactoryBean"变成对象而是将内部的getUserDao方法的返回值，当成对象，将我们指定的id="userDao"
作为BeanName，存储到容器当中;2.<constructor-arg>标签不仅仅是为构造方法传递参数，只要是为了实例化对象而传递的参数都可以通过<constructor-arg>标签完成，例如上面通过静态工厂方法实例化Bean所传递的参数也是要通过<constructor-arg>进行传递的

测试代码，直接通过ApplicationContext获得userDao即可:

ApplicationContext applicationContext = new ClassPathxmlApplicationContext("applicationContext.xml");
Object userDao = applicationContext.getBean("userDao");
System.out.println(userDao);

断点调试，UserDaoImpl实例对象会存在于单例池中：

作用：

1.引入一些第三方的jar包，交给Spring管理时；
2.创建摸个对象之前有一些其他操作；

2)、实例工厂方法：

​ 实例工厂方法，也就是非静态工厂方法产生Bean实例，与静态工厂方式比较，该方式需要先有工厂对象，在用工厂 对象去调用非静态方法，所以在进行配置时，要先配置工厂Bean，在配置目标Bean；

//工厂类
public class UserDaoFactoryBean2 {
//非静态工厂方法
public UserDao getUserDao(String name){
//可以在此编写一些其他逻辑代码
return new UserDaoImpl();
}
}

​ 实例工厂方法，也就是非静态工厂方法产生Bean实例，与静态工厂方式比较，该方式需要先有工厂对象，在用工厂 对象去调用非静态方法，所以在进行配置时，要先配置工厂Bean，在配置目标Bean；

<!-- 配置实例工厂Bean -->
<bean id="userDaoFactoryBean2" class="com.js.factory.UserDaoFactoryBean2"/>
<!-- 配置实例工厂Bean的哪个方法作为工厂方法 -->
<bean id="userDao" factory-bean="userDaoFactoryBean2" factory-method="getUserDao">
<constructor-arg name="name" value="haohao"/>
</bean>

解释

"factory-bean":告诉Spring 容器，实例工厂对象是哪个
"factory-method":告诉Spring 容器，实例工厂对象中的方法是哪个

测试代码，直接通过ApplicationContext获得userDao即可:

ApplicationContext applicationContext = new ClassPathxmlApplicationContext("applicationContext.xml");
Object userDao = applicationContext.getBean("userDao");
System.out.println(userDao);

通过断点观察单例池singletonObjects，发现单例池中既有工厂Bean实例，也有目标Bean实例，且都是在Spring 容器创建时，就完成了Bean的实例化；

3）、Bean的实例化配置：

上面不管是静态工厂方式还是非静态工厂方式，都是自定义的工厂方法，Spring提供了FactoryBean的接口规范， FactoryBean接口定义如下：

public interface FactoryBean<T> {String OBJECT_TYPE_ATTRIBUTE = “factoryBeanObjectType”;T getObject() throws Exception; //获得实例对象方法Class<?> getObjectType(); //获得实例对象类型方法default boolean isSingleton() {return true;}
}

1、定义工厂实现FactoryBean:

public class UserDaoFactoryBean3 implements FactoryBean<UserDao> {//返回Bean是谁public UserDao getObject() throws Exception {return new UserDaoImpl();}//返回bean的类型是啥public Class<?> getObjectType() {return UserDao.class;}
}

2、配置FactoryBean交由Spring管理即可

<bean id="userDao" class="com.js.factory.UserDaoFactoryBean3"/>

3、 通过Spring容器根据beanName可以正常获得UserDaoImp

ApplicationContext applicationContext = new ClassPathxmlApplicationContext("applicationContext.xml");
Object userDao = applicationContext.getBean("userDao");
System.out.println(userDao);

通过断点观察发现Spring容器创建时，FactoryBean被实例化了，并存储到了单例池singletonObjects中，但是 getObject() 方法尚未被执行，UserDaoImpl也没被实例化，当首次用到UserDaoImpl时，才调用getObject() ， 此工厂方式产生的Bean实例不会存储到单例池singletonObjects中，会存储到 factoryBeanObjectCache 缓存池 中，并且后期每次使用到userDao都从该缓存池中返回的是同一个userDao实例。

7）Bean的依赖注入配置

Bean的依赖注入有两种方式：

注入方式	配置方式
通过Bean的set方法注入	<property name="userDao" ref="userDao"/><br/><property name="userDao" value="haohao"/>
通过构造Bean的方法进行注入	<constructor-arg name="name" ref="userDao"/><br/><constructor-arg name="name" value="haohao"/>

​ 其中，ref 是 reference 的缩写形式，翻译为：涉及，参考的意思，用于引用其他Bean的id。value 用于注入普通 属性值。

依赖注入的数据类型有如下三种：

​ ⚫ 普通数据类型，例如：String、int、boolean等，通过value属性指定。

​ ⚫ 引用数据类型，例如：UserDaoImpl、DataSource等，通过 ref 属性指定。

​ ⚫ 集合数据类型，例如：List、Map、Properties等。

一、通过Seet方法进行注入

1）对于list注入：

1. 注入 List 集合 – 普通数据

<property name="strList"><list><value>haohao</value><value>miaomiao</value></list>
</property>

2.注入 List 集合 – 引用数据

<property name="objList"><list><bean class="com.js.dao.impl.UserDaoImpl"></bean><bean class="com.js.dao.impl.UserDaoImpl"></bean><bean class="com.js.dao.impl.UserDaoImpl"></bean></list>
</property>

也可以直接引用容器中存在的Bean

<!--配置UserDao-->
<bean id="userDao" class="com.js.dao.impl.UserDaoImpl"/>
<bean id="userDao2" class="com.js.dao.impl.UserDaoImpl"/>
<bean id="userDao3" class="com.js.dao.impl.UserDaoImpl"/>
<!--配置UserService-->
<bean id="userService" class="com.js.service.impl.UserServiceImpl"><property name="objList"><list><ref bean="userDao"></ref><ref bean="userDao2"></ref><ref bean="userDao3"></ref></list></property>
</bean>

5)、注入 Set 集合

//注入泛型为字符串的Set集合
public void setValueSet(Set<String> valueSet){valueSet.forEach(str->{System.out.println(str);});
}//注入泛型为对象的Set集合
public void setObjSet(Set<UserDao> objSet){objSet.forEach(obj->{System.out.println(obj);});
}

<!-- 注入泛型为字符串的Set集合 -->
<property name="valueSet"><set><value>muzi</value><value>muran</value></set>
</property>
<!-- 注入泛型为对象的Set集合 -->
<property name="objSet"><set><ref bean="userDao"></ref><ref bean="userDao2"></ref><ref bean="userDao3"></ref></set>
</property>

3）、注入 Map 集合

注入 Map <k,y>集合

//注入值为字符串的Map集合
public void setValueMap(Map<String,String> valueMap){valueMap.forEach((k,v)->{System.out.println(k+"=="+v);});
}//注入值为对象的Map集合
public void setObjMap(Map<String,UserDao> objMap){objMap.forEach((k,v)->{System.out.println(k+"=="+v);});
}

<!--注入值为字符串的Map集合-->
<property name="valueMap"><map><entry key="aaa" value="AAA" /><entry key="bbb" value="BBB" /><entry key="ccc" value="CCC" /></map>
</property><!--注入值为对象的Map集合-->
<property name="objMap"><map><entry key="ud" value-ref="userDao"/><entry key="ud2" value-ref="userDao2"/><entry key="ud3" value-ref="userDao3"/></map>
</property>

4)、注入 Properties 键值对

//注入Properties
public void setProperties(Properties properties){properties.forEach((k,v)->{System.out.println(k+"=="+v);});
}

<property name="properties"><props><prop key="xxx">XXX</prop><prop key="yyy">YYY</prop></props>
</property

以上的Bean的依赖注入配置为手动

扩展：自动装配方式

如果被注入的属性类型是Bean引用的话，那么可以在 标签中使用 autowire 属性去配置自动注入方式，属 性值有两个：

⚫ byName：通过属性名自动装配，即去匹配 setXxx 与 id=“xxx”（name=“xxx”）是否一致；

⚫ byType：通过Bean的类型从容器中匹配，匹配出多个相同Bean类型时，报错。

<bean id="userService" class="com.js.service.impl.UserServiceImpl"
autowire="byType">

2.2、Spring 的getBean方法

方法定义	返回值和参数
Object getBean (String beanName)	根据beanName从容器中获取Bean实例，要求容器中Bean唯一，返回值为Object，需要强转
T getBean (Class type)	根据Class类型从容器中获取Bean实例，要求容器中Bean类型唯一，返回值为Class类型实例， 无需强转
T getBean (String beanName，Class type)	根据beanName从容器中获得Bean实例，返回值为Class类型实例，无需强转

//根据beanName获取容器中的Bean实例，需要手动强转
UserService userService = (UserService) applicationContext.getBean("userService");
//根据Bean类型去容器中匹配对应的Bean实例，如存在多个匹配Bean则报错
UserService userService2 = applicationContext.getBean(UserService.class);
//根据beanName获取容器中的Bean实例，指定Bean的Type类型
UserService userService3 = applicationContext.getBean("userService",
UserService.class);

2.3、Spring 配置非自定义Bean

以上在 xml 中配置的Bean都是自己定义的，例如：UserDaoImpl，UserServiceImpl。但是，在实际开发中有些 功能类并不是我们自己定义的，而是使用的第三方jar包中的，那么，这些Bean要想让Spring进行管理，也需要对 其进行配置

配置非自定义的Bean需要考虑如下两个问题：

⚫ 被配置的Bean的实例化方式是什么？无参构造、有参构造、静态工厂方式还是实例工厂方式；

⚫ 被配置的Bean是否需要注入必要属性。

列子：

1）配置 Druid 数据源交由Spring管理

配置 DruidDataSource

<!--配置 DruidDataSource数据源-->
<bean class="com.alibaba.druid.pool.DruidDataSource">
<!--配置必要属性-->
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc://localhost:3306/mybatis"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</bean>

3、基于注解诞的Spring应用

1、Bean基本注解开发

基本Bean注解，主要是使用注解的方式替代原有xml的 标签及其标签属性的配置

<bean id="" name="" class="" scope="" lazy-init="" init-method="" destroy-method=""
abstract="" autowire="" factory-bean="" factory-method=""></bean>

使用@Component 注解替代标签

xml配置	注解	描述
	@Component	被该注解标识的类，会在指定扫描范围内被Spring加载并实例化

可以通过@Component注解的value属性指定当前Bean实例的beanName，也可以省略不写，不写的情况下为当前 类名首字母小写

//获取方式：applicationContext.getBean("userDao");
@Component("userDao")//表示将当前这个Bean创建好的实例对象以指定的名称"userDao" BeanName存储到Spring容器当中
public class UserDaoImpl implements UserDao {
}
//获取方式：applicationContext.getBean("userDaoImpl");
@Component
public class UserDaoImpl implements UserDao {
}

使用注解对需要被Spring实例化的Bean进行标注，但是需要告诉Spring去哪找这些Bean，要配置组件扫描路径

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
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
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<!-- 告知Spring框架去js包及其子包下去扫描使用了注解的类 -->
<context:component-scan base-package="com.js"/>
</beans>

@Component就单纯一个value属性，那么xml配置 时那些属性怎么进行配置呢？Spring 是通过注解方 式去配置的之前 标签中的那些属性，例如：@Scope

<bean id="" name="" class="" scope="" lazy-init="" init-method="" destroy-method=""
abstract="" autowire="" factory-bean="" factory-method=""></bean>

使用@Component 注解替代标签

xml配置	注解	描述
	@Scope	在类上或使用了@Bean标注的方法上，标注Bean的作用范围，取值为 singleton或prototype
	@Lazy	在类上或使用了@Bean标注的方法上，标注Bean是否延迟加载，取值为 true和false
	@PostConstruct	在方法上使用，标注Bean的实例化后执行的方法
	@PreDestroy	在方法上使用，标注Bean的销毁前执行方法

使用上述注解完成UserDaoImpl的基本配置

@Component("userDao")
@Scope("singleton")
@Lazy(true)
public class UserDaoImpl implements UserDao{@PostConstructpublic void init(){sout("初始方法");}@PreDestroypublic void destroy(){sout("销毁方法")}
}

由于JavaEE开发是分层的，为了每层Bean标识的注解语义化更加明确，@Component又衍生出如下三个注解：

@Component衍生注解	描述
@Repository	在Dao层类上使用
@Service	在Service层类上使用（标注在实现类上，因为接口无法直接实例化，只能找他实现类进行实现）
@Controller	在Web层类上使用

@Repository("userDao")
public class UserDaoImpl implements UserDao{}
@Service("userService")
public class UserServiceImpl implements UserService{}
@Controller("userService")
public class UserController {}

2、Bean依赖注入注解开发

Bean依赖注入的注解，主要是使用注解的方式替代xml的 标签完成属性的注入操作

<bean id="" class="">
<property name="" value=""/>
<property name="" ref=""/>
</bean>

Spring主要提供如下注解，用于在Bean内部进行属性注入的：

属性注入注解	描述
@Value	使用在字段或方法上，用于注入普通数据
@Autowired	使用在字段或方法上，用于根据类型（byType）注入引用数据
@Qualifier	使用在字段或方法上，结合@Autowired，根据名称注入
@Resource	使用在字段或方法上，根据类型或名称进行注入

1)、@Value

通过@Value 直接注入普通属性

@Value("haohao")
private String username;
@Value("haohao")
public void setUsername(String username){
System.out.println(username);
}

通过@Value 注入properties文件中的属性

@Value("${jdbc.username}")
private String username;
@Value("${jdbc.username}")
public void setUsername(String username){
System.out.println(username);
}

加载properties文件

<context:property-placeholder location="classpath:jdbc.properties"/>

2)、@Autowired注解

@Autowired注解，用于根据类型进行注入，如果同一类型的Bean有多个，尝试根据名字进行二次匹配，不匹配时会报错

//1、使用在属性上直接注入：
@Autowired
private UserDao userDao;//2、使用在方法上直接注入，他是根据参数类型进行匹配的，方法名可以不是set方法开头的，
@Autowired
public void setUserDao(UserDao userDao){
System.out.println(userDao);
}

当容器中同一类型的Bean实例有多个时，会尝试自动根据名字进行匹配：

//匹配当前Bean
@Repository("userDao")
public class UserDaoImpl implements UserDao{}
@Repository("userDao2")
public class UserDaoImpl2 implements UserDao{}

当容器中同一类型的Bean实例有多个时，且名字与被注入Bean名称不匹配时会报错

@Qualifier配合@Autowired可以完成根据名称注入Bean实例，使用@Qualifier指定名称

@Autowired
@Qualifier("userDao2")
private UserDao userDao;
@Autowired
@Qualifier("userDao2")
public void setUserDao(UserDao userDao){
System.out.println(userDao);
}

3)、@Resource注解

@Resource注解既可以根据类型注入，也可以根据名称注入，无参就是根据类型注入，有参数就是根据名称注入

@Resource
private UserDao userDao;
@Resource(name = "userDao2")
public void setUserDao(UserDao userDao){
System.out.println(userDao);
}

@Resource注解存在与 javax.annotation 包中，Spring对其进行了解析

3、非自定义Bean注解开发

非自定义Bean不能像自定义Bean一样使用@Component进行管理，非自定义Bean要通过工厂的方式进行实例化， 使用@Bean标注方法即可，@Bean的属性为beanName，如不指定为当前工厂方法名称

//将方法返回值Bean实例以@Bean注解指定的名称存储到Spring容器中
@Bean("dataSource")//参数就是BeanName，没有加，以方法名设置为BeanName
public DataSource dataSource(){
DruidDataSource dataSource = new DruidDataSource();dataSource.setDriverClassName("com.mysql.jdbc.Driver");dataSource.setUrl("jdbc:mysql://localhost:3306/mybatis");dataSource.setUsername("root");dataSource.setPassword("root");return dataSource;
}

**注意：**工厂方法所在类必须要被Spring管理

如果@Bean工厂方法需要参数的话，则有如下几种注入方式：

⚫ 使用@Autowired 根据类型自动进行Bean的匹配，@Autowired可以省略 ；

⚫ 使用@Qualifier 根据名称进行Bean的匹配；

⚫ 使用@Value 根据名称进行普通数据类型匹配

@Bean
@Autowired //根据类型匹配参数
public Object objectDemo01(UserDao userDao){System.out.println(userDao);return new Object();
}@Bean
public Object objectDemo02(@Qualifier("userDao") UserDao userDao,@Value("${jdbc.username}") String username){System.out.println(userDao);System.out.println(username);return new Object();
}

4、Bean配置类的注解开发

Bean配置类的注解开发,是使用配置类替代Spring配置文件applicationContext.xml 文件的

@Component等注解替代了标签，但是像、< context:componentScan> 等非 标签怎 样去使用注解替代呢？

<!-- 加载properties文件 -->
<context:property-placeholder location="classpath:jdbc.properties"/>
<!-- 组件扫描 -->
<context:component-scan base-package="com.js"/>
<!-- 引入其他xml文件 -->
<import resource="classpath:beans.xml"/>

定义一个配置类替代原有的xml配置文件，标签以外的标签，一般都是在配置类上使用注解完成的

@Configuration是个组合注解，该注解标识的类为配置类，替代原有xml配置文件，该注解第一个作用是标识该类是一个配置类，第 二个作用是具备@Component作用

@Configuration
public class ApplicationContextConfig {}

@ComponentScan 组件扫描配置，替代原有xml文件中的 <context:component-scan base-package=“”/>

@Configuration
@ComponentScan({"com.js.service","com.js.dao"})
public class ApplicationContextConfig {}

base-package的配置方式：

⚫ 指定一个或多个包名：扫描指定包及其子包下使用注解的类

⚫ 不配置包名：扫描当前@componentScan注解配置类所在包及其子包下的类

@PropertySource 注解用于加载外部properties资源配置，替代原有xml中的<<context:propertyplaceholder location=" "> 配置

@Configuration
@ComponentScan
@PropertySource({"classpath:jdbc.properties","classpath:xxx.properties"})
public class ApplicationContextConfig {}

@Import 用于加载其他配置类，替代原有xml中的配置

@Configuration
@ComponentScan
@PropertySource("classpath:jdbc.properties")
@Import(OtherConfig.class)
public class ApplicationContextConfig {}

4、Spring Aop

1、AOP 简介

1.1、AOP的概念

​ AOP，Aspect Oriented Programming，面向切面编程，是对面向对象编程OOP的升华。OOP是纵向对一个 事物的抽象，一个对象包括静态的属性信息，包括动态的方法信息等。而AOP是横向的对不同事物的抽象，属 性与属性、方法与方法、对象与对象都可以组成一个切面，而用这种思维去设计编程的方式叫做面向切面编程

1.2、AOP思想的实现方案

动态代理技术，在运行期间，对目标对象 的方法进行增强，代理对象同名方法内可 以执行原有逻辑的同时嵌入执行其他增强 逻辑或其他对象的方法

1.3、Aop简介

模拟AOP的基础代码 其实在之前学习BeanPostProcessor时，在BeanPostProcessor的after方法中使用动态代理对Bean进行了增 强，实际存储到单例池singleObjects中的不是当前目标对象本身，而是当前目标对象的代理对象Proxy，这样 在调用目标对象方法时，实际调用的是代理对象Proxy的同名方法，起到了目标方法前后都进行增强的功能， 对该方式进行一下优化，将增强的方法提取出去到一个增强类中，且只对com.js.service.impl包下的任 何类的任何方法进行增强

//自定义增强类
public class MyAdvice {
public void beforeAdvice(){
System.out.println("beforeAdvice ...");
}
public void afterAdvice(){
System.out.println("afterAdvice ...");
}
}

模拟AOP的基础代码:

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.context.ApplicationContextAware;public class MockAopBeanPostProcessor implements BeanPostProcessor, ApplicationContextAware {private ApplicationContext applicationContext;//注入Spring容器对象public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {MyAdvice myAdvice = applicationContext.getBean(MyAdvice.class);//获得Advice对象String packageName = bean.getClass().getPackage().getName();if ("com.js.service.impl".equals(packageName)) {
//对Bean进行动态代理，返回的是Proxy代理对象Object proxyBean = Proxy.newProxyInstance(bean.getClass().getClassLoader(),bean.getClass().getInterfaces(),(Object proxy, Method method, Object[] args) -> {myAdvice.beforeAdvice();//执行Advice的before方法Object result = method.invoke(bean, args);//执行目标myAdvice.afterAdvice();//执行Advice的after方法return result;});
//返回代理对象return proxyBean;}return bean;}public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {this.applicationContext = applicationContext;}
}

1.4、 AOP相关概念

2、基于xml配置的AOP

xml方式AOP快速入门 前面我们自己编写的AOP基础代码还是存在一些问题的，主要如下：

⚫ 被增强的包名在代码写死了

⚫ 通知对象的方法在代码中写死了

通过配置文件的方式去解决上述问题

⚫ 配置哪些包、哪些类、哪些方法需要被增强

⚫ 配置目标方法要被哪些通知方法所增强，在目标方法执行之前还是之后执行增强 配置方式的设计、配置文件（注解）的解析工作，Spring已经帮我们封装好了

2.1、xml方式配置AOP的步骤：

1、导入AOP相关坐标；

<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.6</version>
</dependency>

---

2、准备目标类、准备增强类，并配置给Spring管理；

目标类	增强类
public interface UserService { void show1(); void show2(); } public class UserServiceImpl implements UserService { public void show1() { System.out.println(“show1…”); } public void show2() { System.out.println(“show2…”); }}	public class MyAdvice { public void beforeAdvice(){ System.out.println(“beforeAdvice”); } public void afterAdvice(){ System.out.println(“afterAdvice”); } }

<!--配置目标类,内部的方法是连接点-->
<bean id="userService" class="com.js.service.impl.UserServiceImpl"/>
<!--配置通知类,内部的方法是增强方法-->
<bean id=“myAdvice" class="com.js.advice.MyAdvice"/>

3、配置切点表达式（哪些方法被增强）；

4、配置织入（切点被哪些通知方法增强，是前置增强还是后置增强）。

<aop:config>
<!--配置切点表达式,对哪些方法进行增强-->
<aop:pointcut id="myPointcut" expression="execution(void
com.js.service.impl.UserServiceImpl.show1())"/>
<!--切面=切点+通知-->
<aop:aspect ref="myAdvice">
<!--指定前置通知方法是beforeAdvice-->
<aop:before method="beforeAdvice" pointcut-ref="myPointcut"/>
<!--指定后置通知方法是afterAdvice-->
<aop:after-returning method="afterAdvice" pointcut-ref="myPointcut"/>
</aop:aspect>
</aop:config

第二种：(提出到外面)

2.2、xml配置AOP的的细节：

⚫ 切点表达式的配置方式

​ 切点表达式的配置方式有两种，直接将切点表达式配置在通知上，也可以将切点表达式抽取到外面，在通知上 进行引用：

<aop:config>
<!--配置切点表达式,对哪些方法进行增强-->
<aop:pointcut id="myPointcut" expression="execution(void
com.js.service.impl.UserServiceImpl.show1())"/>
<!--切面=切点+通知-->
<aop:aspect ref="myAdvice">
<!--指定前置通知方法是beforeAdvice-->
<aop:before method="beforeAdvice" pointcut-ref="myPointcut"/>
<!--指定后置通知方法是afterAdvice-->
<aop:after-returning method="afterAdvice" pointcut="execution(void
com.js.service.impl.UserServiceImpl.show1())"/>
</aop:aspect>
</aop:config>

⚫ 切点表达式的配置语法

​ 切点表达式是配置要对哪些连接点（哪些类的哪些方法）进行通知的增强，语法如下：

execution([访问修饰符]返回值类型 包名.类名.方法名(参数))

其中:

• 访问修饰符可以省略不写；

• 返回值类型、某一级包名、类名、方法名 可以使用 * 表示任意；

• 包名与类名之间使用单点 . 表示该包下的类，使用双点 … 表示该包及其子包下的类；

• 参数列表可以使用两个点 … 表示任意参数

切点表达式举几个例子:

//表示访问修饰符为public、无返回值、在com.itheima.aop包下的TargetImpl类的无参方法show
execution(public void com.itheima.aop.TargetImpl.show())
//表述com.itheima.aop包下的TargetImpl类的任意方法
execution(* com.itheima.aop.TargetImpl.*(..))
//表示com.itheima.aop包下的任意类的任意方法
execution(* com.itheima.aop.*.*(..))
//表示com.itheima.aop包及其子包下的任意类的任意方法
execution(* com.itheima.aop..*.*(..))
//表示任意包中的任意类的任意方法
execution(* *..*.*(..))

⚫ 通知的类型

通知名称	配置方式	执行时机
前置通知	< aop:before >	目标方法执行之前执行
后置通知	< aop:after-returning >	目标方法执行之后执行，目标方法异常时，不在执行
环绕通知	< aop:around >	目标方法执行前后执行，目标方法异常时，环绕后方法不在执行
异常通知	< aop:after-throwing >	目标方法抛出异常时执行
最终通知	< aop:after >	不管目标方法是否有异常，最终都会执行

⚫ AOP的配置的方式(aspect)

• 环绕通知

public void around(ProceedingJoinPoint joinPoint) throws Throwable {//环绕前System.out.println("环绕前通知");//目标方法joinPoint.proceed();///环绕后System.out.println("环绕后通知");
}

<aop:around method="around" pointcut-ref="myPointcut"/>

• 异常通知

异常通知，当目标方法抛出异常时，异常通知方法执行，且后置通知和环绕后通知不在执行

public void afterThrowing(){
System.out.println("目标方法抛出异常了，后置通知和环绕后通知不在执行");
}

<aop:after-throwing method="afterThrowing" pointcut-ref="myPointcut"/>

• 最终通知

最终通知，类似异常捕获中的finally，不管目标方法有没有异常，最终都会执行的通知

public void after(){
System.out.println("不管目标方法有无异常，我都会执行");
}

<aop:after method="after" pointcut-ref="myPointcut"/>

2.2、通知方法在被调用时传递参数

参数类型	作用
JoinPoint	连接点对象，任何通知都可使用，可以获得当前目标对象、目标方法参数等信息
ProceedingJoinPoint	JoinPoint子类对象，主要是在环绕通知中执行proceed()，进而执行目标方法
Throwable	异常对象，使用在异常通知中，需要在配置文件中指出异常对象名称

• JoinPoint 对象：

public void 通知方法名称(JoinPoint joinPoint){//获得目标方法的参数System.out.println(joinPoint.getArgs());//获得目标对象System.out.println(joinPoint.getTarget());//获得精确的切点表达式信息System.out.println(joinPoint.getStaticPart());
}

• ProceedingJoinPoint

public Object around(ProceedingJoinPoint joinPoint) throws Throwable {System.out.println(joinPoint.getArgs());//获得目标方法的参数System.out.println(joinPoint.getTarget());//获得目标对象System.out.println(joinPoint.getStaticPart());//获得精确的切点表达式信息Object result = joinPoint.proceed();//执行目标方法return result;//返回目标方法返回值
}

• Throwable

2.3、AOP的另一种配置方式: advisor 方式(了解即可)：

AOP的另一种配置方式，该方式需要通知类实现Advice的子功能接口 Advice的子功能接口

public interface Advice {
}

Advice的子功能接口:

例如：通知类实现了前置通知和后置通知接口

public class Advices implements MethodBeforeAdvice, AfterReturningAdvice {
public void before(Method method, Object[] objects, Object o) throws Throwable {System.out.println("This is before Advice ...");}public void afterReturning(Object o, Method method, Object[] objects, Object o1) throwsThrowable {System.out.println("This is afterReturn Advice ...");}
}

切面使用advisor标签配置:不用指定通知方式，而是以实现的接口中的方法，来执行

<aop:config>
<!-- 将通知和切点进行结合 -->
<aop:advisor advice-ref="advices" pointcut="execution(void com.js.aop.TargetImpl.show())"/>
</aop:config>

又例如：通知类实现了方法拦截器接口

public class MyMethodInterceptor implements MethodInterceptor {@Overridepublic Object invoke(MethodInvocation methodInvocation) throws Throwable {System.out.println("前置逻辑功能...");//执行目标方法Object invoke =methodInvocation.getMethod().invoke(methodInvocation.getThis(),methodInvocation.getArguments());System.out.println("后置逻辑功能...");return invoke;}
}

切面使用advisor标签配置

<aop:config>
<!-- 将通知和切点进行结合 -->
<aop:advisor advice-ref=“myMethodInterceptor" pointcut="execution(void
com.itheima.aop.TargetImpl.show())"/>
</aop:config>

2.4、使用aspect和advisor配置区别如下：

• 配置语法不同：

<!-- 使用advisor配置 -->
<aop:config>
<!-- advice-ref:通知Bean的id -->
<aop:advisor advice-ref="advices" pointcut="execution(void
com.itheima.aop.TargetImpl.show())"/>
</aop:config>
<!-- 使用aspect配置 -->
<aop:config>
<!-- ref:通知Bean的id -->
<aop:aspect ref="advices">
<aop:before method="before" pointcut="execution(void
com.itheima.aop.TargetImpl.show())"/>
</aop:aspect>
</aop:config>

• 通知类的定义要求不同，advisor 需要的通知类需要实现Advice的子功能接口：

public class Advices implements MethodBeforeAdvice {
public void before(Method method, Object[] objects, Object o) throws Throwable {System.out.println("This is before Advice ...");
}
public void afterReturning(Object o, Method method, Object[] objects, Object o1) throwsThrowable {System.out.println("This is afterReturn Advice ...");}
}

aspect 不需要通知类实现任何接口，在配置的时候指定哪些方法属于哪种通知类型即可，更加灵活方便：

public class Advices {
public void before() {System.out.println("This is before Advice ...");
}public void afterReturning() {System.out.println("This is afterReturn Advice ...");}
}

• 可配置的切面数量不同：

  • 一个advisor只能配置一个固定通知和一个切点表达式；
  • 一个aspect可以配置多个通知和多个切点表达式任意组合，粒度更细。

• 使用场景不同：

  • 如果通知类型多、允许随意搭配情况下可以使用aspect进行配置；
  • 如果通知类型单一、且通知类中通知方法一次性都会使用到的情况下可以使用advisor进行配置；
  • 在通知类型已经固定，不用人为指定通知类型时，可以使用advisor进行配置，例如后面要学习的Spring事务 控制的配置；

由于实际开发中，自定义aop功能的配置大多使用aspect的配置方式，所以我们后面主要讲解aspect的配置， advisor是为了后面Spring声明式事务控制做铺垫，此处大家了解即可。

3、基于注解配置的AOP

3.1、注解方式AOP基本使用

目标类被Spring容器管理、通知类被Spring管理

@Component("target")
public class TargetImpl implements Target{public void show() {System.out.println("show Target running...");}
}
@Component
public class AnnoAdvice {
public void around(ProceedingJoinPoint joinPoint) throws Throwable {System.out.println("环绕前通知...");joinPoint.proceed();System.out.println("环绕后通知...");}
}

配置aop，其实配置aop主要就是配置通知类中的哪个方法（通知类型）对应的切点表达式是什么

@Component
@Aspect //第一步
public class AnnoAdvice {
@Around("execution(* com.itheima.aop.*.*(..))") //第二步
public void around(ProceedingJoinPoint joinPoint) throws Throwable {System.out.println("环绕前通知...");joinPoint.proceed();System.out.println("环绕后通知...");}
}

注解@Aspect、@Around需要被Spring解析，所以在Spring核心配置文件中需要配置aspectj的自动代理

<aop:aspectj-autoproxy/>

配置aop，其实配置aop主要就是配置通知类中的哪个方法（通知类型）对应的切点表达式是什么

如果核心配置使用的是配置类的话，需要配置注解方式的aop自动代理

@Configuration
@ComponentScan("com.itheima.aop")
@EnableAspectJAutoProxy //第三步
public class ApplicationContextConfig {
}

3.2、各种注解方式通知类型

//前置通知
@Before("execution(* com.itheima.aop.*.*(..))")
public void before(JoinPoint joinPoint){}
//后置通知
@AfterReturning("execution(* com.itheima.aop.*.*(..))")
public void AfterReturning(JoinPoint joinPoint){}
//环绕通知
@Around("execution(* com.itheima.aop.*.*(..))")
public void around(ProceedingJoinPoint joinPoint) throws Throwable {}
//异常通知
@AfterThrowing("execution(* com.itheima.aop.*.*(..))")
public void AfterThrowing(JoinPoint joinPoint){}
//最终通知
@After("execution(* com.itheima.aop.*.*(..))")
public void After(JoinPoint joinPoint){}

3.3、切点表达式的抽取

@Component
@Aspect
public class AnnoAdvice {//切点表达式抽取@Pointcut("execution(* com.itheima.aop.*.*(..))")public void pointcut(){}//前置通知@Before("pointcut()")public void before(JoinPoint joinPoint){}//后置通知@AfterReturning("AnnoAdvice.pointcut()")public void AfterReturning(JoinPoint joinPoint){}// ... 省略其他代码 ...
}

4、基于AOP的声明式事务控制