spring所需的jar包
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>4.2.4.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.2.4.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>4.2.4.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-expression</artifactId>
<version>4.2.4.RELEASE</version>
</dependency>
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>1.2</version>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
使用spring编程
ApplicationContext第一种:
//创建Spring的工厂
ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
//通过工厂获得类
UserService userService=(UserService) applicationContext.getBean("userService");
userService.sayHello();
ApplicationContext第二种:
//创建Spring的工厂类
ApplicationContext applicationContext=new FileSystemXmlApplicationContext("d:\\applicationContext.xml");
//通过工厂获得工厂类
UserService userService=(UserService) applicationContext.getBean("userService");
userService.sayHello();
SpringIOC和DI
IOC就是将创建对象的控制权交给了Spring框架管理。
DI就是依赖注入,依赖于IOC,在Spring创建对象的时候将对象的属性也注入进去。
<!--IOC控制反转,创建对象-->
<bean id="userService" class="com.zs.demo1.UserServiceImpl">
<!--DI依赖注入成员变量-->
<property name="name" value="zhang"></property>
</bean>
BeanFactory与ApplicatiomContext区别
- applicationContext的功能要更多一些。
- BeanFactory与ApplicationContext生成bean实例的时机不同:BeanFactory是在工厂实例化完后去调用getBean的时候才会去创建对象的实例,applicationContext是在加载配置文件的时候,就会将配置文件中的所有单例模式生成的类全部实例化。
Spring的Bean管理
三种实例化bean的方式
- 使用类的无参构造方法(默认这种)
package com.zs.demo2;
/**
* 无参构造方法
*/
public class Bean1 {
public Bean1(){
System.out.println("第一种:无参构造");
}
}
<!--第一种:无参构造实现-->
<bean id="bean1" class="com.zs.demo2.Bean1"></bean>
@Test
public void demo1(){
//创建工厂
ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationCOntext.xml");
//通过工厂获得类的实例
Bean1 bean1=(Bean1)applicationContext.getBean("bean1");
}
- 使用静态工厂方法实例化(工厂模式)
package com.zs.demo2;
/**
* 静态工厂方法实例化
*/
public class Bean2 {
}
package com.zs.demo2;
/**
* Bean2的静态工厂
*/
public class Bean2Factory {
public static Bean2 createBean2(){
System.out.println("第二种:静态工厂方法实例化");
return new Bean2();
}
}
<!--第二种:静态工厂方法实例化实现-->
<bean id="bean2" class="com.zs.demo2.Bean2Factory" factory-method="createBean2"></bean>
@Test
public void demo2(){
//创建工厂
ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationCOntext.xml");
//通过工厂获得类的实例
Bean2 bean2=(Bean2) applicationContext.getBean("bean2" );
}
- 使用实例工厂方法实例化(工厂方法模式)
package com.zs.demo2;
/**
* 实例工厂方法实例化
*/
public class Bean3 {
}
package com.zs.demo2;
/**
* Bean3的静态工厂
*/
public class Bean3Factory {
public Bean3 createBean3(){
System.out.println("第三种:实例工厂方法实例化");
return new Bean3();
}
}
<!--第三种:实例工厂方法实例化实现-->
<bean id="bean3Factory" class="com.zs.demo2.Bean3Factory"></bean>
<bean id="bean3" factory-bean="bean3Factory" factory-method="createBean3"></bean>
@Test
public void demo3(){
//创建工厂
ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationCOntext.xml");
//通过工厂获得类的实例
Bean3 bean3=(Bean3) applicationContext.getBean("bean3" );
}
Bean的常用配置
- id和name:id和name在中都要唯一,区别在于,名称中含有特殊字符使用name
- class:用于设置一个类的完全路径名称,主要生成类的实例
Bean的作用域
类别 | 说明 |
---|---|
singleton | 在SpringIOC容器中仅存在一个Bean实例,以 单实例的方式存在 |
prototype | 每次调用getBean()时都会返回一个新的实例 |
request | 每次HTTP请求都会创建一个新的Bean,该作用域仅使适用于WebApplicationContext环境 |
session | 同一个HTTP Session共享一个Bean,不同的HTTP Session使用不同的Bean。该作用域仅适用于WebApplicationContext环境 |
Bean的整个生命周期
Spring在创建和销毁bean的时候调用bean的两个生命周期方法。
<bean id="" class="" init-method="" destroy-method=""></bean>
init-method:当bean被载入到容器的时候调用里面的方法
destroy-method:当bean从容器中删除的时候调用里面的方法(单例模式有效)
- instantiate bean对象实例化
- popuplate properties封装属性
- 如果Bean实现BeanNameAware执行setBeanName
- 如果Bean实现BeanFactoryAway或者ApplicationContextAware设置工厂setBeanFactory或者上下文对象setApplicationContext
- 如果存在类实现BeanPostProcessor(后处理Bean),执行postProcessBeforeInitialization(重点!!!)
- 如果Bean实现InitializingBean执行afterPropertiesSet
- 调用中的指定初始化方法
- 如果存在类实现BeanPostProcessor(处理Bean),执行postProcessAfterInitialization(重点!!)
- 执行业务处理
- 如果Bean实现DisposableBean执行destroy
- 调用中的指定销毁方法
package com.zs.demo3;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
public class Person implements BeanNameAware, ApplicationContextAware, InitializingBean, DisposableBean {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
System.out.println("第二步:设置属性");
this.name = name;
}
public Person(){
System.out.println("第一步:初始化");
}
public void setUp(){
System.out.println("第七步:Person被初始化");
}
public void destroyDown(){
System.out.println("第十一步:Person被销毁了");
}
@Override
public void setBeanName(String s) {
System.out.println("第三步:设置Bean的名称");
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
System.out.println("第四步:了解工厂的信息");
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("第六步:属性设置后");
}
public void run(){
System.out.println("第九步:执行业务方法");
}
@Override
public void destroy() throws Exception {
System.out.println("第十步:执行Spring中的销毁方法");
}
}
package com.zs.demo3;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
public class MyBeanPostProcess implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String s) throws BeansException {
System.out.println("第五步:初始化前方法");
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String s) throws BeansException {
System.out.println("第八步:初始化后方法");
return bean;
}
}
<bean id="person" class="com.zs.demo3.Person" init-method="setUp" destroy-method="destroyDown">
<property name="name" value="zhangsan"></property>
</bean>
<bean class="com.zs.demo3.MyBeanPostProcess"></bean>
BeanPostProcessor的作用
package com.zs.demo3;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.cglib.proxy.InvocationHandler;
import org.springframework.cglib.proxy.Proxy;
import java.lang.reflect.Method;
public class MyBeanPostProcess implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String s) throws BeansException {
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String s) throws BeansException {
if ("userDao".equals(s)){
Object proxy= Proxy.newProxyInstance(bean.getClass().getClassLoader(), bean.getClass().getInterfaces(), new InvocationHandler() {
@Override
public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
if ("select".equals(method.getName())){
System.out.println("权限校验=======");
method.invoke(bean,objects);
}
return method.invoke(bean,objects);
}
});
return proxy;
}else {
return bean;
}
}
}
对类进行增强,对其功能性完善
Spring的属性注入——Set方法注入
在配置文件中通过标签设置注入的属性