1,什么是spring框架
spring是J2EE应用程序框架,是轻量级的IoC和AOP的容器框架,主要是针对javaBean的生命周期进行管理的轻量级容器,可以单独使用,也可以和Struts框架,ibatis框架等组合使用。
2.框架概述
1)IoC(Inversion of Control)控制反转,对象创建责任的反转,在spring中BeanFacotory是IoC容器的核心接口,负责实例化,定位,配置应用程序中的对象及建立这些对象间的依赖。XmlBeanFacotory实现BeanFactory接口,通过获取xml配置文件数据,组成应用对象及对象间的依赖关系。
spring中有三种注入方式,一种是set注入,一种是接口注入,另一种是构造方法注入。
2)AOP面向切面编程
aop就是纵向的编程,如下图所示,业务1和业务2都需要一个共同的操作,与其往每个业务中都添加同样的代码,不如写一遍代码,让两个业务共同使用这段代码。
spring中面向切面变成的实现有两种方式,一种是动态代理,一种是CGLIB,动态代理必须要提供接口,而CGLIB实现是有继承。
3,为什么使用spring框架
在不使用spring框架之前,我们的service层中要使用dao层的对象,不得不在service层中new一个对象。如下:
//dao层对象
public class UserDao{
publicvoid insert(User user){}
}
//service层对象
public classUserService{
publicvoid insert(User user){
UserDaouserdao = new UserDao();
userdao.insert(user);
}
}
存在的问题:层与层之间的依赖。
使用框架后:
//dao层对象
public class UserDao{
publicvoid insert(User user){}
}
//service层对象
public classUserService{
privateUserDao userdao;
publicUserDao getUserdao() {
returnuserdao;
}
publicvoid setUserdao(UserDao userdao) {
this.userdao= userdao;
}
publicvoid insert(User user){
userdao.insert(user);
}
}
service层要用dao层对象需要配置到xml配置文件中,至于对象是怎么创建的,关系是怎么组合的都交给了spring框架去实现。
4,框架优点
轻量级的容器框架没有侵入性
使用IoC容器更加容易组合对象直接间关系,面向接口编程,降低耦合
Aop可以更加容易的进行功能扩展,遵循ocp开发原则
创建对象默认是单例的,不需要再使用单例模式进行处理
5,缺点:业务功能依赖spring特有的功能,依赖与spring环境。
6. 依赖注入的实现方式
(1)属性setter方法注入
指Spring容器使用setter方法注入被依赖的实例,通过调用无参构造器或者无参静态工厂方法实例化Bean后,调用该Bean的setter方法,就可以实现基于setter方法的依赖注入。
简单说就是,在调用者的实例中声明一下被调用者,并生成一个被调用者的setter方法即可,然后在配置文件中依赖注入被调用者的Bean,实质就是调用了该Bean中的setter方法。
(2)构造方法注入
指Spring容器使用构造方法注入被依赖的实例。基于构造方法的依赖注入通过调用带参数的构造方法来实现,每个参数代表这一个依赖。
使用一个实例来说明Spring中如何实现依赖注入
(一)创建UserService接口及其实现类UserServiceImpl
//UserService接口
package com.fu.service;
public interface UserService {
public void sayHi();
}
//UserService接口的实现类UserServiceImpl
package com.haust.service.impl;
import com.fu.dao.UserDao;
import com.fu.service.UserService;
public class UserServiceimpl implements UserService {
private UserDao userDao;
//添加UserDao属性的setter方法,用于实现依赖注入
public void setUserDao(UserDao userdao) {
this.userDao = userdao;
}
//实现接口中的方法
@Override
public void sayHi() {
//调用userDao中的say()方法,并执行输出语句
userDao.sayHi();
System.out.println("UserService say hello");
}
}
(二)在配置文件中添加userService的Bean,并将userDao的实例注入到userService中
<bean id="userService" class="com.fu.service.impl.UserServiceimpl">
<property name="userDao" ref="userDao"></property>
</bean>
(三)创建测试类
@Test
public void run12(){
//1.创建容器对象
ApplicationContext applicationContext =
new ClassPathXmlApplicationContext("applicationContext.xml");
//2.通过容器对象获取bean对象
UserService user = (UserService)applicationContext.getBean("userService");
user.sayHi();
}
7.编写JDK动态代理代码
(1)创建接口,定义方法
public interface UserDao {
public int add(int a,int b);
public String update(String id);
}
public class UserDaoImp1 implements UserDao{
@Override
public int add(int a, int b) {
System.out.println("add方法执行了");
return a+b;
}
@Override
public String update(String id) {
System.out.println("update方法执行了");
return id;
}
}
(2)创建接口实现类,实现方法.,创建代理对象。需要用到的方法
每一个动态代理类的调用处理程序都必须实现InvocationHandler接口,当我们通过动态代理对象调用一个方法时候,这个方法的调用就会被转发到实现InvocationHandler接口类的invoke方法来调用
public class JDKProxy {
public static void main(String[] args) {
// 创建接口实现类文件
// 第二个参数
Class[] interfaces = {UserDao.class};
// 匿名类写法
// Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new InvocationHandler() {
// @Override
// public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// return null;
// }
// });
UserDaoImp1 u = new UserDaoImp1();
UserDao o = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(u));
int a = o.add(1, 2);
System.out.println(a);
}
}
//创建代理对象码
class UserDaoProxy implements InvocationHandler{
// 想要增强UserDaoImp1的代理对象,所以将UserDaoImp1传进来,这样才能将之前的方法和扩展的方法执行
//有参传递
//(可传UserDaoImp1 imp1)但object更通用,这部分实现的是之前要实现的方法
private Object obj;
public UserDaoProxy(Object obj){
this.obj = obj;
}
// 增强逻辑
@Override
// proxy:代理对象 method :当前方法 args:参数
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("方法之前执行"+method.getName()+"传递的参数"+ Arrays.toString(args));
//method.invoke()方法,用来执行某个的对象的目标方法。
// 被增强的方法执行,obj:对象 args:参数
Object res = method.invoke(obj, args);
// 方法之后
System.out.println("方法之后执行"+obj);
return res;
}
}
invoke方法来委托动态构造的对应类型对象,使其执行对应形参的add方法,这是回调函数(方法)的功能。回调函数不是由该函数的实现方直接调用,而是在特定的事件或条件发生时由另外的一方调用的,用于对该事件或条件进行响应。
8.切入点表达式
(1)切入点表达式作用:知道对哪个类里面的哪个方法进行增强
(2)语法结构:
execution([权限修饰符[返回类型[类全路径][方法名称[参数列表D)
权限修饰符可以具体,*代表任一修饰符
返回类型可以省略
Aop注解操作(AspectJ)
@Aspect:作用是把当前类标识为一个切面供容器读取
@Pointcut:Pointcut是植入Advice的触发条件。每个Pointcut的定义包括2部分,一是表达式,二是方法签名。方法签名必须是 public及void型。可以将Pointcut中的方法看作是一个被Advice引用的助记符,因为表达式不直观,因此我们可以通过方法签名的方式为 此表达式命名。因此Pointcut中的方法只需要方法签名,而不需要在方法体内编写实际代码。
@Around:环绕增强,相当于MethodInterceptor
@AfterReturning:后置增强,相当于AfterReturningAdvice,方法正常退出时执行
@Before:标识一个前置增强方法,相当于BeforeAdvice的功能,相似功能的还有
@AfterThrowing:异常抛出增强,相当于ThrowsAdvice
@After: final增强,不管是抛出异常或者正常退出都会执行
1.创建类,在类里面定义方法
//被增强的类
@Component
public class User {
public void add(){
// int i =10/0;
System.out.println("add....");
}
}
2.创建增强类(编写增强逻辑)
(1)在增强类里面,创建方法,让不同方法代表不同通知类型
//增强的类
@Component
@Aspect//生成代理对象
public class UserProxy {
// 前置通知
@Before(value="execution(* com.java.aop.aopanno.User.add(..))")
// 要求:让这个方法比User类里的addfangfa之前执行:前置通知
// 被增强的方法
public void before(){
System.out.println("befor...");
}
// 后置通知
@After(value="execution(* com.java.aop.aopanno.User.add(..))")
public void after(){
System.out.println("after...");
}
//后置异常
@AfterThrowing(value="execution(* com.java.aop.aopanno.User.add(..))")
public void afterThrowing(){
System.out.println("afterThrowing...");
}
//后置增强
@AfterReturning(value="execution(* com.java.aop.aopanno.User.add(..))")
public void afterReturning(){
System.out.println("afterReturning...");
}
//环绕增强
@Around(value="execution(* com.java.aop.aopanno.User.add(..))")
public void round(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
System.out.println("环绕之前.");
//该方法表示调用增强的方法
proceedingJoinPoint.proceed();
System.out.println("环绕之后");
}
}
After:无论是否有异常都输出
AfterReturning:有异常不输出
、进行通知的配置
(1)在spring配置文件中,开启注解扫描
(2)使用注解创建User和UseProxy对象
(3)在增强类上面添加注解@Aspedt
(4)在spring配置文件中开启生成代理对象
<?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"
xmlns:aop="http://www.springframework.org/schema/aop"
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
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
<!--开启注解扫描-->
<context:component-scan base-package="com.java.aop"></context:component-scan>
<!-- 开启Aspect生成代理对象,找到含有@Aspect注解的类将此类生成代理对象-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>