Spring基础知识自我扫盲

目前在看Spring相关的漏洞，然额我只知道Spring是Java的一个框架，听说过IOC和AOP，其他一概不知>_<，咱怀着敬畏的心情，浅显的了解了一下Spring。

Java的框架太多了，顺便把常用的都查了下到底都是干啥的>_<

 

Java比较著名的框架

MVC框架

• struts1：最早的MVC框架，封装的是servlet，有很多bug和漏洞，完全被淘汰
• struts2：其实跟struts1是完全不同的东东，基本被淘汰
• springMVC：目前的主流

持久层框架

• hibernate：全自动的持久层框架。只需要建立配置文件，并配置好表之间的关系，就自动创建表了crud只需要调用相关方法即可，不需要写sql语句
• mybatis：半自动持久层框架，需要自己写sql语句
• JDBC：纯手动持久层框

 

Spring基础知识

Spring既不是MVC框架，也不是持久层框架，而是一个开源的整合型和设计型框架，它的两大核心是IOC和AOP。

IOC(Inversion of Control)：控制反转。是一种设计思想。Java在实现IOC的时候采用的设计模式是工厂模式

DI(Dependency Injection)：依赖注入。是Spring对IOC思想的实现方式

AOP(AOP-Aspect Oriented Programming)：面向切面的编程。Java在实现AOP的时候采用的设计模式是动态代理模式

 

1. Spring的特性

• 非侵入性：对Spring API的依赖性不强，意思就是使用Spring框架的时候，使用Spring的API和不使用Spring的API都可以跑起来
• 依赖注入：控制反转（IOC）最经典的实现
• 面向切面编程
• 容器：Spring是一个容器，管理对象的生命周期
• 组件化：Spring的组件就是Spring管理的对象
• 一站式：整合各种开源框架和第三方类库（Spring自身的表述层是SpringMVC，持久层是Spring JDBC）

 

2. IOC和DI

关于Spring的IOC和DI的实现，个人的浅显理解是这样的：

Spring有自己的配置文件(必须要有)，默认命名为applicationContext.xml，长下面这个样子：

具体的调用实现：

 

3. AOP

要了解AOP，首先要了解动态代理，因为Java是通过动态代理模式实现的AOP。

网上参考的动态代理的例子：

public interface Calculator {

    int add(int i,int j);
    int sub(int i ,int j);
    int mul(int i ,int j);
    int div(int i ,int j);
}

public class CauculatorImpl implements Calculator {
    public int add(int i, int j) {
        return i+j;
    }

    public int sub(int i, int j) {
        return i-j;
    }

    public int mul(int i, int j) {
        return i*j;
    }

    public int div(int i, int j) {
        return i/j;
    }
}

public class MyLogger {

    public static void before(String methodName, Object args) {

        System.out.println("method:" + methodName + ", arguments:" + args);
    }

    public static void after(String methodName, Object args) {
        System.out.println("method:" + methodName + ", arguments:" + args);
    }
}

public class ProxyUtil {

    private Object calImpl;

    public ProxyUtil(Object calImpl){
        super();
        this.calImpl=calImpl;
    }

    public Object getProxy(){

        //使用当前类的类加载器
        ClassLoader loader=this.getClass().getClassLoader();
        //获取目标对象所实现的所有接口
        Class[] interfaces = calImpl.getClass().getInterfaces();

        //用JDK的Proxy类创建动态代理 - 前提是目标对象必须实现了接口
        //new InvocationHandler - 匿名内部类, InvocationHandler用来设置(通过invoke方法来设置)代理对象如何实现目标对象的方法
        return Proxy.newProxyInstance(loader, interfaces, new InvocationHandler() {

            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                MyLogger.before(method.getName(), Arrays.toString(args));
                Object result= method.invoke(calImpl,args); //这里代理对象通过调用目标对象的方法，才能保证代理产生的结果和目标对象要求的结果一致
                MyLogger.after(method.getName(),result);
                return result;
            }
        });
    }

}

 

AOP的相关概念：

• 横切关注点：咱理解为需要被多处使用的公共功能（比如上面例子中的日志功能）
• 切面：把横切关注点抽取出来，用来封装横切关注点的类
• 通知：个人理解为横切关注点被添加到切面之后，就叫通知（比如上面例子中Mylogger类中的before和after方法都是通知）
• 代理对象：向目标对象应用通知之后创建的代理对象（比如上面例子中的ProxyUtil）
• 目标对象：被通知的对象（比如上面例子中的Calculator）
• 连接点：功能执行中的各个位置（如，前，后，异常抛出等）
• 切入点：定义通知被应用的位置（在哪些连接点）。如果连接点是数据库中的记录，切入点就是查询条件

嗯，反正我是被这些概念整晕了，说明AOP我理解的很不咋地。。。 

AOP有专门的开源框架可以用，咱觉得目前理解到这里已经够用了，以后有时间再学习AOP框架吧>_<