spring框架学习

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>