Spring框架入门基础

小咪咪 2022-03-21 11:26 228阅读 0赞

## 介绍 ##

> Spring是一个分层的(一站式) 轻量级开源框架  
> Spring的核心是控制反转（IoC）和面向切面（AOP）

### 为什么说分层一站式呢？ ###

> javaEE分三层开发 WEB层，业务层，持久层。在ssh整合框架中s == Struts2， s == spring，h == Hibernate ,spring 的一站式开发就是不用struts2 和hibernate，在spring中有SpringMvc可以替代Struts2，springJDBC可以替代Hibernate。等于一个spring框架可以快速开发JavaEE应用。关于轻量级就不太多说了，spring整个框架打包出来也才1M多的内存大小。spring运行中的消耗也不大。那肯定是轻量级的框架。

### Spring的模块 ###

组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下：

![Image 1][]

> 1.  核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转 （IOC） 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。
> 2.  Spring 上下文：Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。
> 3.  Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向方面的编程功能集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理的任何对象支持 AOP。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖 EJB 组件，就可以将声明性事务管理集成到应用程序中。
> 4.  Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。
> 5.  Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。
> 6.  Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。
> 7.  **Spring MVC 框架**：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。

--------------------

### 什么是IOC的功能？ ###

**概念**

> IoC -- Inverse of Control，控制反转，将对象的创建权反转给Spring！！  
> 使用IOC可以解决的程序耦合性高的问题！！

**控制反转**

> 假设我需要做一个功能，在这个功能当中我需要调用servic层，然后再调用dao层，去取数据。在传统的javaEE开发中我就直接去new一个service 然后再new一个dao。但是在spring框架中，我们吧new service和new dao的权利交个spring框架，假设我需要使用我就直接去spring框架中寻找。等于说我的资源创建的权利交给了spring框架，这就叫做控制反转。

**解耦**

> 刚刚我们说资源创建交给了sring，我们需要什么就找spring。这过程就像是工厂模式。但是在spring框架中它需要创建哪些对象，它需要一个配置文件。这个配置文件告诉spring，需要创建哪些资源。

例如：假设我需要去数据库查询数据显示页面

> 程序启动，spring框架去找配置文件创建资源，把资源放置再一个容器中，开始运行，前端请求数据，在spring中找controller层，再找service层，再找dao层要数据，最后数据原路返回controller，再显示到页面上。其中service被spring注入到controlller层，dao层被spring注入到service层。这个过程分工明确。每一层各司其职。传统的一个开发，在servlet中直接new然后去查数据，然后数据返回到界面上。万一操作一多所有的判断，查询不同的表，这个servlet的代码变得十分的臃肿。不说开发慢，你开发完了看代码也费劲。 所以说控制反转可以用来解耦

--------------------

### 什么是面向切面（AOP）？ ###

**概念**

*  在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程
 *  AOP是一种编程范式，隶属于软工范畴，指导开发者如何组织程序结构
 *  AOP最早由AOP联盟的组织提出的,制定了一套规范.Spring将AOP思想引入到框架中,必须遵守AOP联盟的规范
 *  通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术
 *  AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型
 *  利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率

> 其实AOP可以在不修改源代码的前提下，对程序进行增强！！

**Spring框架的AOP的底层实现**

1. Spring框架的AOP技术底层也是采用的代理技术，代理的方式提供了两种

> 1. 基于JDK的动态代理

必须是面向接口的，只有实现了具体接口的类才能生成代理对象

> 2. 基于CGLIB动态代理

对于没有实现了接口的类，也可以产生代理，产生这个类的子类的方式

2. Spring的传统AOP中根据类是否实现接口，来采用不同的代理方式

> 1.  如果实现类接口，使用JDK动态代理完成AOP
> 2.  如果没有实现接口，采用CGLIB动态代理完成AOP

**JDK的动态代理**

**注意：需要实现类接口**

> 例子：假设我有两个工作，工作1，工作2.

//写一个接口
    public interface Working {
        void wokingOne();
    
        void WorkingTwo();
    }

//接口实现类
    public class WorkingImpl implements Working {
        @Override
        public void wokingOne() {
            System.out.println("做任务1");
        }
    
        @Override
        public void WorkingTwo() {
            System.out.println("做任务2");
        }
    }

> 好的，现在我要先做任务1，然后再做任务2我们的写法为:

public static void main(String[] args) {
            Working working = new WorkingImpl();
            working.wokingOne();//做任务1
            working.WorkingTwo();//做任务2
        }

> 好的精彩的地方来了,我再做任务2之前我要先休息10分钟，但是不能修改源代码。怎么办呢？这时候就用到我们的JDK动态代理了。代码如下：

> 先写一个代理的工具类。再做任务2前我们休息十分钟

public class MyProxyUtils {
        public static Working getProxy(final Working working) {
            // 使用Proxy类生成代理对象
            Working proxy = (Working) Proxy.newProxyInstance(working.getClass().getClassLoader(),
                    working.getClass().getInterfaces(), new InvocationHandler() {
    
                        // 代理对象方法一直线，invoke方法就会执行一次
                        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                            //再做工作2之前我先休息10分钟
                            if ("WorkingTwo".equals(method.getName())) {
                                System.out.println("休息10分钟");
                            }
                            //工作继续进行下去
                            return method.invoke(working, args);
                        }
                    });
            // 返回代理对象
            return proxy;
        }
    }

public static void main(String[] args) {
            Working working = new WorkingImpl();
            Working proxy = MyProxyUtils.getProxy(working);
            proxy.wokingOne();
            proxy.WorkingTwo();
    
        }

运行的结果可想而知：

做任务1
    休息10分钟
    做任务2

**CGLIB动态代理**

**注意：没有实现类接口**

> CGLIB也是一个java项目，所以要使用它就要引入CGLIB的开发的jar包，**因为在Spring框架核心包（core）中已经引入了CGLIB的开发包了**。所以直接引入Spring核心开发包即可

**好我们同样使用上面的例子来做事例吧**

//工作类
    public class Working {
    
        public void wokingOne() {
            System.out.println("做任务1");
        }
    
        public void WorkingTwo() {
            System.out.println("做任务2");
        }
    }

> new一个对象调用任务1 任务2得到的结果这个就没必要说了。我们重点看下怎么使用CGLIB来在不改变源码的情况下，做任务之前休息十分钟。

public static Working getProxy(){
            // 创建CGLIB核心的类
            Enhancer enhancer = new Enhancer();
            // 设置父类
            enhancer.setSuperclass(Working.class);
            // 设置回调函数
            enhancer.setCallback(new MethodInterceptor() {
                @Override
                public Object intercept(Object obj, Method method, Object[] args,
                        MethodProxy methodProxy) throws Throwable {
                    if("WorkingTwo".equals(method.getName())){
                        // 休息10分钟
                        System.out.println("休息10分钟...");
                    }
                    return methodProxy.invokeSuper(obj, args);
                }
            });
            // 生成代理对象
            Working proxy = (Working) enhancer.create();
            return proxy;
        }

public static void main(String[] args) {
            Working working = new WorkingImpl();
            Working proxy = MyCglibUtils.getProxy(working);
            proxy.wokingOne();
            proxy.WorkingTwo();
    
        }

最后的运行结果也是相同的：

做任务1
    休息10分钟
    做任务2

### 分析 ###

我上面简单分析了一下spring AOP的底层实现的两种方式：JDK动态代理，CGLIB。在Spring框架中它会自动选择使用哪一种方式。如果有接口实现类，那就使用jdk动态代理，没有接口就使用CGLIB。有了这个功能那么我们修改东西就方便多了。假设我再做任务一前我需要记录下日志。我就直接写一个切面类，直接去记录日志。都不用修改本身的源码。

[Image 1]: