Spring框架的使用

我会带着你远行 2021-10-13 03:41 313阅读 0赞

# 一，spring框架需要的jar包（必备jar包） #

![\[外链图片转存失败(img-8z71nva8-1566371826845)(D:\\文件笔记\\image\\1565776139074.png)\]][img-8z71nva8-1566371826845_D_image_1565776139074.png]

# 二，创建一个项目（感受一下bean的存在） #

在src文件夹中新建一个配置文件applicationContext.xml文件，至于上面的配置就去官网上面查吧，文件内容中配置了bean就可以在java代码中使用。

applicationContext.xml文件的位置一般都放在src下面。

**注意：文件名是定死的，不能变。**

![\[外链图片转存失败(img-kZc5Y7ky-1566371826846)(D:\\文件笔记\\image\\1565776197714.png)\]][img-kZc5Y7ky-1566371826846_D_image_1565776197714.png]

<?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:p="http://www.springframework.org/schema/p"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">
        
       
        <bean id="someService" class="com.qianlong.test.SomeServiceImpl"></bean>  
    </beans>

然后写几个方法

public interface ISomeService { 
    	void doSome();
    }

public class SomeServiceImpl implements ISomeService { 
    	@Override
    	public void doSome() { 
    		System.out.print("hello");
    	}
    }

然后写测试类，在这里分别不使用spring容器和使用spring容器拿到someService。

public class Test { 
    public static void main(String[] args) { 
    	//不适用spring容器（缺点：SomeServiceImpl这个类，完全耦合到了测试类）
    	//ISomeService someService=new SomeServiceImpl();
    	//someService.doSome();
    	
    	//使用spring容器：创建容器
    	ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
    	ISomeService iSomeService=(ISomeService) ac.getBean("someService");
    	iSomeService.doSome();
    }
    }

可以从d盘加载配置文件applicationContext.xml文件，首先把配置文件放在d盘的位置。

//从d盘加载配置文件
    	//创建容器
    	ApplicationContext ac=new FileSystemXmlApplicationContext("D:/spring/applicationContext.xml");
    	ISomeService someService1=(ISomeService) ac.getBean("someService");
    	someService1.doSome();

可以直接使用beanFactory容器

//直接使用beanFactory容器
    	BeanFactory bf=new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
    	ISomeService service=(ISomeService) bf.getBean("someService");
    	service.doSome();

结果都可以new出来SomeServiceImpl这个对象并且调用这个对象的方法。

## applicationContext容器和BeanFactory容器的区别 ##

*  applicationContext容器：在初始化容器时，就将容器中的所有对象进行了创建。
 *  BeanFactory容器：使用时才创建。

# 三，bean的装配 #

bean的装配就是bean对象的创建，容器根据代码要求创建bean对象后再传递给代码的过程，成为bean的装配。代码通过getBean()方式从容器获取指定的bean实例，容器首先会调用bean类的无参构造器，创建控制的实例对象。

## 动态工厂bean ##

使用工厂模式创建bean实例，就会使工厂类与要创建的bean类耦合到一起。

先写一个工厂类，这里工厂类返回一个SomeServiceImpl类。

public class SomeFactory { 
    	public ISomeService getSomeService() { 
    		return new SomeServiceImpl();
    	}
    }

然后把这个工厂类写入bean中。

<bean id="someFactory" class="com.qianlong.test.SomeFactory"></bean>

容器先得到工厂，然后工厂再生产出想要的类。

但是这样写的话工厂类和测试类又耦合到了一起，所以不能这样写。

//动态工厂装配bean
    	ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
    	SomeFactory factory=(SomeFactory) ac.getBean("someFactory");
    	ISomeService service=factory.getSomeService();
    	service.doSome();

应该怎么写？

applicationContext.xml文件

<bean id="someFactory" class="com.qianlong.test.SomeFactory"></bean>
       
        <bean id="someService" factory-bean="someFactory" factory-method="getSomeService"></bean>

测试类

//动态工厂装配bean
    	//创建容器
    	ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
    	//容器中的工厂bean创建处service类
    	ISomeService service=(ISomeService) ac.getBean("someService");
    	service.doSome();

## 静态工厂bean ##

生成someService类的静态工厂类

public class SomeFactory { 
    	public static ISomeService getSomeService() { 
    		return new SomeServiceImpl();
    	}
    }

在applicationContext.xml文件中写入bean

<bean id="someService" class="com.qianlong.test.SomeFactory" factory-method="getSomeService"></bean>

然后创建容器，再由容器中的静态工厂bean创建service类

//创建容器
    	ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
    	ISomeService service=(ISomeService) ac.getBean("someService");
    	service.doSome();

# 四，Bean的作用域 #

当通过spring容器创建一个bean实例时，还可以通过scope属性，为bean指定特定的作用域，spring支持5种作用域。

*  singleton，单例模式，即在整个spring容器中，使用singleton定义的bean是单例的，只有一个实例。bean默认是单例模式。
 *  prototype，原型模式，每次使用getBean方法获取的同一个实例都是一个新的实例
 *  request，对于每次HTTP请求，都将产生一个不同的bean实例。
 *  session，对于每个不同的HTTP session，都将产生一个不同的bean实例。
 *  global session，每个全局的HTTP session对应一个Bean实例。

例如

<bean id="someService" class="com.qianlong.test.SomeServiceImpl" scope="prototype"></bean>

# 五，Bean后处理器 #

bean后处理器是一种特殊的bean，容器中所有的bean在初始化时，都会自动执行bean后处理器的两个方法，由于该bean是由其他bean自动调用执行，不是程序员手工调用，所以这个bean不需要id属性。

写一个类实现BeanPostProcessor接口，并重写方法。

public class MyBeanPostProcessor implements BeanPostProcessor { 
    	//bean:当前正在被初始化的bean
    	//beanName：当前正被初始化的bean的id
    	//在当前bean的所有属性均被初始化完毕之前 执行该方法
    	@Override
    	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { 
    		System.out.println("执行bean后处理器的before方法");
    		return bean;
    	}
    	//在当前bean的所有属性均被初始化完毕之前 执行该方法
    	@Override
    	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { 
    		System.out.println("执行bean后处理器的after方法");
    		return null;
    	}
    }

在xml中注入bean

<bean class="com.qianlong.test.MyBeanPostProcessor"></bean>
        <bean id="someService" class="com.qianlong.test.SomeServiceImpl"></bean>

然后在测试类中使用容器创建bean时，会先执行bean后处理器的两个方法，然后在创建someService对象成功。

ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
    	ISomeService service=(ISomeService) ac.getBean("someService");
    	System.out.println(service);

打印结果会先打印bean后处理器的方法，然后再打印service对象。

![\[外链图片转存失败(img-ew62oaLl-1566371826847)(D:\\文件笔记\\image\\1565944193507.png)\]][img-ew62oaLl-1566371826847_D_image_1565944193507.png]

# 六，定制Bean的生命周期初末 #

可以为bean定制初始化后的生命行为，也可以为bean定制销毁前的生命行为。

public class SomeServiceImpl implements ISomeService { 
    	@Override
    	public void doSome() { 
    		System.out.print("hello");
    	}
    	
    	public void beanInit() { 
    		System.out.println("bean刚被初始化");
    	}
    	public void preDestroy() { 
    		System.out.println("bean要被销毁了");
    	}
    }

在xml指定初始化和销毁是哪两个方法

使用容器创建bean并关闭容器，写测试类

ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
    	ISomeService service=(ISomeService) ac.getBean("someService");
    	service.doSome();
    	/** * 若要看到销毁方法的执行，需要两个条件 * bean需要是singleton单例的 * 手工将容器关闭 * ApplicationContext没有close方法，但是它的实现类ClassPathXmlApplicationContext有close方法 */
    	((ClassPathXmlApplicationContext)ac).close();

![\[外链图片转存失败(img-7veju6wR-1566371826847)(D:\\文件笔记\\image\\1565945703914.png)\]][img-7veju6wR-1566371826847_D_image_1565945703914.png]

# 七，基于XML的DI #

## 设值注入 ##

写一个实体类，然后再xml文件中写入信息，最后使用容器创建该实体对象并且打印，会打印出xml写入的信息。

public class Student { 
    	private String name;
    	private Integer age;
    }

测试类

ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
    	Student student=(Student) ac.getBean("student");
    	System.out.println(student);

打印结果

![在这里插入图片描述][20190821151943838.png]

那么问题来了，如果student实体类中有一个属性是对象，那这个对象在xml中如何赋值？

比如说

public class Student { 
    	private String name;
    	private Integer age;
    	private School school;
    }

先注入School到bean中，然后在student的bean下的property中使用ref属性指向school的bean的id即可。

## 构造器注入 ##

给实体类写一个构造器

public class Student { 
    	private String name;
    	private Integer age;
    	public Student() { 
    	}
    	
    	public Student(String name, Integer age) { 
    		super();
    		this.name = name;
    		this.age = age;
    	}
    }

在xml中注入信息

测试类

ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
    	Student student=(Student) ac.getBean("student");
    	System.out.println(student);

![在这里插入图片描述][20190821152000401.png]

## p命名空间设值注入 ##

student类

public class Student { 
    	private String name;
    	private Integer age;
    	private School school;
    }

school类

public class School { 
    	private String name;
    }

xml配置

测试类

ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
    	Student student=(Student) ac.getBean("student");
    	System.out.println(student);

![\[外链图片转存失败(img-VzBvD7IJ-1566371826848)(D:\\文件笔记\\image\\1565949882945.png)\]][img-VzBvD7IJ-1566371826848_D_image_1565949882945.png]

p命名空间设值注入的支持是

![\[外链图片转存失败(img-dajNNFlG-1566371826849)(D:\\文件笔记\\image\\1565958366464.png)\]][img-dajNNFlG-1566371826849_D_image_1565958366464.png]

## c命名空间设值注入 ##

和上面的p命名空间一样的道理，在applicationContext.xml文件中引入c命名空间的支持就可以了，然后和p命名空间同样的使用方式。这里省略不讲了。

c命名空间设值注入支持

![\[外链图片转存失败(img-7UK8T2LF-1566371826849)(D:\\文件笔记\\image\\1565958481259.png)\]][img-7UK8T2LF-1566371826849_D_image_1565958481259.png]

# 八，基于注解的注入 #

基于注解的注入需要aop jar包底层的支持，在applicationContext.xml文件的约束中需要添加context约束。

http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd

## 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" 4 xmlns:context="http://www.springframework.org/schema/context" 5 xmlns:aop="http://www.springframework.org/schema/aop" 6 xmlns:tx="http://www.springframework.org/schema/tx" 7 xsi:schemaLocation="http://www.springframework.org/schema/beans 8 http://www.springframework.org/schema/beans/spring-beans.xsd 9 http://www.springframework.org/schema/context 10 http://www.springframework.org/schema/context/spring-context.xsd 11 http://www.springframework.org/schema/aop 12 http://www.springframework.org/schema/aop/spring-aop.xsd 13 http://www.springframework.org/schema/tx 14 http://www.springframework.org/schema/tx/spring-tx.xsd">
    15     
    16 </beans>

加上包扫描注解内容

<context:component-scan base-package="com.qianlong.test"></context:component-scan>

@Component("myStudent")	//表明当前类为组件，容器创建的这个组件名称为myStudent，相当于bean的id属性
    //与本注解具有相同意义的注解还有三个
    //@Reponsitory 注解在Dao
    //@Service 注解在service
    //@Controller 注解在controller
    @Scope("prototype")	//设置bean的作用范围，默认是singleton
    public class Student { 
    	@Value("张三")	//为name属性赋值
    	private String name;
    	@Value("23")
    	private Integer age;

然后进行测试

ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
    	Student student=(Student) ac.getBean("myStudent");
    	System.out.println(student);

![\[外链图片转存失败(img-t2GquAnb-1566371826849)(D:\\文件笔记\\image\\1565961300930.png)\]][img-t2GquAnb-1566371826849_D_image_1565961300930.png]

## 使用@Resource为域属性自动注入 ##

student类

@Component("myStudent")	//表明当前类为组件，容器创建的这个组件名称为myStudent，相当于bean的id属性
    public class Student { 
    	@Value("张三")	//为name属性赋值
    	private String name;
    	@Value("23")
    	private Integer age;
    	@Resource
    	private School school;
    }

school类

@Component("mySchool")
    public class School { 
    	@Value("清华大学")
    	private String name;
    }

同样，xml文件加上包扫描之后才能识别上面的注解，上面已经说过，这里忽略。

直接测试

ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
    	Student student=(Student) ac.getBean("myStudent");
    	System.out.println(student);

![\[外链图片转存失败(img-L3KwhG62-1566371826850)(D:\\文件笔记\\image\\1565961859249.png)\]][img-L3KwhG62-1566371826850_D_image_1565961859249.png]

## 使用@Autowired为域属性自动注入 ##

把上面的@Resource注解换成@Autowired也可以达到上述的效果。

## JavaConfig注解 ##

写一个student实体类，这里需要加上带参构造器，xml包扫描。

public class Student { 
    	public Student(String name, Integer age) { 
    		super();
    		this.name = name;
    		this.age = age;
    	}

写一个JavaConfig类

@Configuration	//表明当前POJO类将被当作配置文件来使用，即spring容器
    public class JavaConfig { 
    	@Bean(name="mySchool")	//表明当前方法的返回值为一个bean对象
    	public School mySchoolCreator() { 
    		return new School("清华大学");//school实体类需要加上构造器
    	}
    	
    	@Bean(name="myStudent")
    	public Student getStudent() { 
    		return new Student("赵六", 18);
    	}
    }

上面@Bean注解后面name的值是创建的bean对象名称，然后测试

ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
    	Student student=(Student) ac.getBean("myStudent");
    	System.out.println(student);

然后会打印出学生的信息。

# 九，aop面向切面编程 #

aop其实就是面向切面编程，切入到执行主业务的方法中然后加入交叉逻辑业务。

## 使用jdk的动态代理实现切面编程 ##

aop面向切面编程的底层就是由jdk的动态代理模式实现的。

先写接口和实现类

public interface SomeService { 
    	void doSome();
    	String doSecond();
    }

public class SomeServiceImpl implements SomeService { 
    	@Override
    	public void doSome() { 
    		System.out.println("执行了doSome方法");
    	}
    	@Override
    	public String doSecond() { 
    		System.out.println("执行了doSecond方法");
    		return "China";
    	}
    }

在测试类中写jdk动态代理，在invoke方法中写想要实现的交叉逻辑。

public class Test { 
    public static void main(String[] args) { 
    	SomeService target=new SomeServiceImpl();
    	//代理模式实现交叉业务逻辑切入到主业务中
    	SomeService proxy=(SomeService) Proxy.newProxyInstance(
    			target.getClass().getClassLoader(), target.getClass().getInterfaces(),
    			new InvocationHandler() { 
    				//交叉业务逻辑是在invoke方法里完成的
    				@Override
    				public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
    					System.out.println("开启事务");
    					Object result=method.invoke(target, args);
    					System.out.println("开启日志");
    					return result;
    				}
    			});
    	proxy.doSecond();
    }
    }

执行结果

![\[外链图片转存失败(img-otpVRaix-1566371826850)(D:\\文件笔记\\image\\1566032272708.png)\]][img-otpVRaix-1566371826850_D_image_1566032272708.png]

## aop的使用 ##

### 前置通知MethodBeforeAdvice ###

定义前置通知，需要实现MethodBeforeAdvice接口，该接口中有一个方法before()，会在目标方法执行之前执行。

和上面一样，准备好接口和实现类。

public interface SomeService { 
    	void doSome();
    	String doSecond();
    }

public class SomeServiceImpl implements SomeService { 
    	@Override
    	public void doSome() { 
    		System.out.println("执行了doSome方法");
    	}
    }

写前置通知，就是写一个类实现MethodBeforeAdvice接口，在该类中写前置内容。

//前置通知
    public class MyMethodBeforeAdvice implements MethodBeforeAdvice { 
    	//该方法在目标方法执行之前先执行
        //arg0：目标方法
        //arg1：目标方法的参数列表
        //arg2：目标对象
    	@Override
    	public void before(Method arg0, Object[] arg1, Object arg2) throws Throwable { 
    		System.out.println("目标方法执行之前执行：对目标对象的增强代码就是写在这里的");
    	}
    }

在applicationContext.xml文件中配置（目标对象、前置通知、代理对象，其中代理对象关联了前两者，最后由容器创建代理对象进行调用即可）

<bean id="someService" class="com.qianlong.test.SomeServiceImpl"></bean>   
    		
    	  <bean id="beforeAdvice" class="com.qianlong.test.MyMethodBeforeAdvice"></bean>
    	  
    	  
    	  <bean id="serviceProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
    	  <property name="target" ref="someService"></property>
              
    	  <property name="interfaces" value="com.qianlong.test.SomeService"></property>
    	  <property name="interceptorNames" value="beforeAdvice"></property>
    	  </bean>

测试类

public static void main(String[] args) { 
    	ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
    	//这里是得到代理类的bean
    	SomeService service=(SomeService) ac.getBean("serviceProxy");
    	service.doSome();
    }

打印结果

![\[外链图片转存失败(img-wIcsoKbF-1566371826851)(D:\\文件笔记\\image\\1566035200492.png)\]][img-wIcsoKbF-1566371826851_D_image_1566035200492.png]

### 后置通知AfterReturningAdvice ###

定义后置通知，需要实现接口AfterReturningAdvice，该接口中有一个方法afterReturning()，会在目标方法执行之后执行。

这里和前置通知的操作一样，只不过替换了目标对象为后置通知的类。测试类写法相同，测试结果如下

//后置通知 虽然可以获取到目标方法的返回值，但是不能改变
    public class MyAfterReturningAdvice implements AfterReturningAdvice { 
        //arg0：目标方法返回值
    	@Override
    	public void afterReturning(Object arg0, Method arg1, Object[] arg2, Object arg3) throws Throwable { 
    		System.out.println("目标方法执行之后执行");
    	}
    }

<bean id="someService" class="com.qianlong.test.SomeServiceImpl"></bean>   
    		
    	  <bean id="afterAdvice" class="com.qianlong.test.MyAfterReturningAdvice"></bean> 
    	  
    	  <bean id="serviceProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
    	  <property name="target" ref="someService"></property>
    	  <property name="interfaces" value="com.qianlong.test.SomeService"></property>
    	  <property name="interceptorNames" value="afterAdvice"></property>
    	  </bean>

![\[外链图片转存失败(img-5A1GCBH0-1566371826851)(D:\\文件笔记\\image\\1566036041255.png)\]][img-5A1GCBH0-1566371826851_D_image_1566036041255.png]

### 环绕通知MethodInterceptor ###

定义环绕通知，需要实现接口MethodInterceptor。

public class MyMethodInterceptor implements MethodInterceptor { 
    	@Override
    	public Object invoke(MethodInvocation invocation) throws Throwable { 
    		System.out.println("目标方法执行之前");
    		//调用目标方法
    		Object result=invocation.proceed();
    		System.out.println("目标方法执行之后");
    		return result;
    	}
    }

xml配置bean

<bean id="someService" class="com.qianlong.test.SomeServiceImpl"></bean>   
    		
    	  <bean id="aroundAdvice" class="com.qianlong.test.MyMethodInterceptor"></bean>
    	  
    	  
    	  <bean id="serviceProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
    	  <property name="target" ref="someService"></property>
    	  <property name="interfaces" value="com.qianlong.test.SomeService"></property>
    	  <property name="interceptorNames" value="aroundAdvice"></property>

测试

ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
    	//这里是得到代理类的bean
    	SomeService service=(SomeService) ac.getBean("serviceProxy");
    	service.doSome();

运行结果

![\[外链图片转存失败(img-hA5j8rhs-1566371826852)(D:\\文件笔记\\image\\微信截图\_20190821145954.png)\]][img-hA5j8rhs-1566371826852_D_image_20190821145954.png]

# 十，AspectJ对aop的实现 #

## AspectJ的切入点表达式 ##

学习时间有限，以后有时间再进行补充。

[img-8z71nva8-1566371826845_D_image_1565776139074.png]: /images/20211013/d4f09bed6c6642fa92adb2e870995d3d.png
[img-kZc5Y7ky-1566371826846_D_image_1565776197714.png]: /images/20211013/04542b566ebc4bf09d736474d95fcc36.png
[img-ew62oaLl-1566371826847_D_image_1565944193507.png]: /images/20211013/7f0f47e418c74c56886bfa1526d5655d.png
[img-7veju6wR-1566371826847_D_image_1565945703914.png]: /images/20211013/deaf8f0d683d4327a302d8880cab737d.png
[20190821151943838.png]: /images/20211013/81b60326399249d085641f07bcf6708d.png
[20190821152000401.png]: /images/20211013/bf5b2aa8e99e4030be4a44cef4458a4e.png
[img-VzBvD7IJ-1566371826848_D_image_1565949882945.png]: /images/20211013/51fb04c079434e63b66b450811627989.png
[img-dajNNFlG-1566371826849_D_image_1565958366464.png]: /images/20211013/019b819e4af24d399f7bf06e1be94a21.png
[img-7UK8T2LF-1566371826849_D_image_1565958481259.png]: /images/20211013/42b1a9b1cab444b2adfbd58f25465184.png
[img-t2GquAnb-1566371826849_D_image_1565961300930.png]: /images/20211013/44047475ccaa45dd8ddef34cbb3049bf.png
[img-L3KwhG62-1566371826850_D_image_1565961859249.png]: /images/20211013/88c5b198d41e4a1083309dab1073e62f.png
[img-otpVRaix-1566371826850_D_image_1566032272708.png]: /images/20211013/0a00fff0c3cb45a491ddc3a0859a0078.png
[img-wIcsoKbF-1566371826851_D_image_1566035200492.png]: /images/20211013/7226590658914bf78174344a2dcc1820.png
[img-5A1GCBH0-1566371826851_D_image_1566036041255.png]: /images/20211013/3fd50d4a5f6e41fe86762ee89c8b20d8.png
[img-hA5j8rhs-1566371826852_D_image_20190821145954.png]: /images/20211013/09619d090fe648baa4c5c811f0137c3a.png