【转载】Spring学习(1)——快速入门--2019.05.19

认识 spring 框架

spring 框架是 java 应用最广的框架，它的成功来源于理念，而不是技术本身，它的理念包括 ioc (inversion of control，控制反转) 和 aop(aspect oriented programming，面向切面编程)。

什么是 spring：

1. spring 是一个轻量级的 di / ioc 和 aop 容器的开源框架，来源于 rod johnson 在其著作《expert one on one j2ee design and development》中阐述的部分理念和原型衍生而来。
2. spring 提倡以“最少侵入”的方式来管理应用中的代码，这意味着我们可以随时安装或者卸载 spring

• 适用范围：任何 java 应用
• spring 的根本使命：简化 java 开发

尽管 j2ee 能够赶上 spring 的步伐，但 spring 并没有停止前进， spring 继续在其他领域发展，而 j2ee 则刚刚开始涉及这些领域，或者还没有完全开始在这些领域的创新。移动开发、社交 api 集成、nosql 数据库、云计算以及大数据都是 spring 正在涉足和创新的领域。spring 的前景依然会很美好。

spring 中常用术语：

• 框架：是能完成一定功能的半成品。
  框架能够帮助我们完成的是：项目的整体框架、一些基础功能、规定了类和对象如何创建，如何协作等，当我们开发一个项目时，框架帮助我们完成了一部分功能，我们自己再完成一部分，那这个项目就完成了。
• 非侵入式设计：
  从框架的角度可以理解为：无需继承框架提供的任何类
  这样我们在更换框架时，之前写过的代码几乎可以继续使用。
• 轻量级和重量级：
  轻量级是相对于重量级而言的，轻量级一般就是非入侵性的、所依赖的东西非常少、资源占用非常少、部署简单等等，其实就是比较容易使用，而重量级正好相反。
• javabean：
  即符合 javabean 规范的 java 类
• pojo：即 plain old java objects，简单老式 java 对象
  它可以包含业务逻辑或持久化逻辑，但不担当任何特殊角色且不继承或不实现任何其它java框架的类或接口。

注意：bean 的各种名称——虽然 spring 用 bean 或者 javabean 来表示应用组件，但并不意味着 spring 组件必须遵循 javabean 规范，一个 spring 组件可以是任意形式的 pojo。

• 容器：
  在日常生活中容器就是一种盛放东西的器具，从程序设计角度看就是装对象的的对象，因为存在放入、拿出等操作，所以容器还要管理对象的生命周期。

spring 的优势

• 低侵入 / 低耦合 （降低组件之间的耦合度，实现软件各层之间的解耦）
• 声明式事务管理（基于切面和惯例）
• 方便集成其他框架（如mybatis、hibernate）
• 降低 java 开发难度
• spring 框架中包括了 j2ee 三层的每一层的解决方案（一站式）

spring 能帮我们做什么

①.spring 能帮我们根据配置文件创建及组装对象之间的依赖关系。
②.spring 面向切面编程能帮助我们无耦合的实现日志记录，性能统计，安全控制。
③.spring 能非常简单的帮我们管理数据库事务。
④.spring 还提供了与第三方数据访问框架（如hibernate、jpa）无缝集成，而且自己也提供了一套jdbc访问模板来方便数据库访问。
⑤.spring 还提供与第三方web（如struts1/2、jsf）框架无缝集成，而且自己也提供了一套spring mvc框架，来方便web层搭建。
⑥.spring 能方便的与java ee（如java mail、任务调度）整合，与更多技术整合（比如缓存框架）。

spring 的框架结构

• data access/integration层包含有jdbc、orm、oxm、jms和transaction模块。
• web层包含了web、web-servlet、websocket、web-porlet模块。
• aop模块提供了一个符合aop联盟标准的面向切面编程的实现。
• core container(核心容器)：包含有beans、core、context和spel模块。
• test模块支持使用junit和testng对spring组件进行测试。

---

spring ioc 和 di 简介

ioc：inverse of control（控制反转）

• 读作“反转控制”，更好理解，不是什么技术，而是一种设计思想，就是将原本在程序中手动创建对象的控制权，交由spring框架来管理。
• 正控：若要使用某个对象，需要自己去负责对象的创建
• 反控：若要使用某个对象，只需要从 spring 容器中获取需要使用的对象，不关心对象的创建过程，也就是把创建对象的控制权反转给了spring框架
• 好莱坞法则：don’t call me ,i’ll call you

一个例子

控制反转显然是一个抽象的概念，我们举一个鲜明的例子来说明。

在现实生活中，人们要用到一样东西的时候，第一反应就是去找到这件东西，比如想喝新鲜橙汁，在没有饮品店的日子里，最直观的做法就是：买果汁机、买橙子，然后准备开水。值得注意的是：这些都是你自己“主动”创造的过程，也就是说一杯橙汁需要你自己创造。

然而到了今时今日，由于饮品店的盛行，当我们想喝橙汁时，第一想法就转换成了找到饮品店的联系方式，通过电话等渠道描述你的需要、地址、联系方式等，下订单等待，过一会儿就会有人送来橙汁了。

请注意你并没有“主动”去创造橙汁，橙汁是由饮品店创造的，而不是你，然而也完全达到了你的要求，甚至比你创造的要好上那么一些。

编写第一个 spring 程序

1. 新建一个空的 java 项目，命名为【spring】
2. 新建一个名为【lib】的目录，并添加进必要的 jar 包，导入项目

1. 在 packge【pojo】下新建一个【source】类：

package pojo;

public class source {  
    private string fruit;   // 类型
    private string sugar;   // 糖分描述
    private string size;    // 大小杯    
    /* setter and getter */
}

1. 在 【src】 目录下新建一个 【applicationcontext.xml】 文件，通过 xml 文件配置的方式装配我们的 bean

<?xml version="1.0" encoding="utf-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/xmlschema-instance"
       xsi:schemalocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean name="source" class="pojo.source">
        <property name="fruit" value="橙子"/>
        <property name="sugar" value="多糖"/>
        <property name="size" value="超大杯"/>
    </bean>
</beans>

1. 在 packge【test】下新建一个【testspring】类：

package test;

import org.junit.test;
import org.springframework.context.applicationcontext;
import org.springframework.context.support.classpathxmlapplicationcontext;
import pojo.source;

public class testspring {

    @test
    public void test(){
        applicationcontext context = new classpathxmlapplicationcontext(
                new string[]{"applicationcontext.xml"}
        );

        source source = (source) context.getbean("source");
        system.out.println(source.getfruit());
        system.out.println(source.getsugar());
        system.out.println(source.getsize());
    }
}

1. 运行测试代码，可以正常拿到 xml 配置的 bean

• 总结：
• 传统的方式：
  通过new 关键字主动创建一个对象
• ioc方式：
  对象的生命周期由spring来管理，直接从spring那里去获取一个对象。 ioc是反转控制 (inversion of control)的缩写，就像控制权从本来在自己手里，交给了spring。
  

参考地址：

di：dependency injection（依赖注入）

• 指 spring 创建对象的过程中，将对象依赖属性（简单值，集合，对象）通过配置设值给该对象

继续上面的例子

1. 在 packge【pojo】下新建一个【juicemaker】类：

package pojo;

public class juicemaker {

    // 唯一关联了一个 source 对象
    private source source = null;

    /* setter and getter */

    public string makejuice(){
        string juice = "xxx用户点了一杯" + source.getfruit() + source.getsugar() + source.getsize();
        return juice;
    }
}

1. 在 xml 文件中配置 juicemaker 对象：

• 注意：这里要使用 ref 来注入另一个对象

<?xml version="1.0" encoding="utf-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/xmlschema-instance"
       xsi:schemalocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean name="source" class="pojo.source">
        <property name="fruit" value="橙子"/>
        <property name="sugar" value="多糖"/>
        <property name="size" value="超大杯"/>
    </bean>
    <bean name="juickmaker" class="pojo.juicemaker">
        <property name="source" ref="source" />
    </bean>
</beans>

1. 在 【testspring】 中添加如下代码：

package test;

import org.junit.test;
import org.springframework.context.applicationcontext;
import org.springframework.context.support.classpathxmlapplicationcontext;
import pojo.juicemaker;
import pojo.source;

public class testspring {

    @test
    public void test(){
        applicationcontext context = new classpathxmlapplicationcontext(
                new string[]{"applicationcontext.xml"}
        );

        source source = (source) context.getbean("source");
        system.out.println(source.getfruit());
        system.out.println(source.getsugar());
        system.out.println(source.getsize());

        juicemaker juicemaker = (juicemaker) context.getbean("juickmaker");
        system.out.println(juicemaker.makejuice());
    }
}

1. 运行测试代码：

总结：ioc 和 di 其实是同一个概念的不同角度描述，di 相对 ioc 而言，明确描述了“被注入对象依赖 ioc 容器配置依赖对象”

ioc 如何实现的

最后我们简单说说ioc是如何实现的。想象一下如果我们自己来实现这个依赖注入的功能，我们怎么来做？ 无外乎：

1. 读取标注或者配置文件，看看juicemaker依赖的是哪个source，拿到类名
2. 使用反射的api，基于类名实例化对应的对象实例
3. 将对象实例，通过构造函数或者 setter，传递给 juicemaker

我们发现其实自己来实现也不是很难，spring实际也就是这么做的。这么看的话其实ioc就是一个工厂模式的升级版！当然要做一个成熟的ioc框架，还是非常多细致的工作要做，spring不仅提供了一个已经成为业界标准的java ioc框架，还提供了更多强大的功能，所以大家就别去造轮子啦！希望了解ioc更多实现细节不妨通过学习spring的源码来加深理解！

引用地址：

---

spring aop 简介

如果说 ioc 是 spring 的核心，那么面向切面编程就是 spring 最为重要的功能之一了，在数据库事务中切面编程被广泛使用。

aop 即 aspect oriented program 面向切面编程

首先，在面向切面编程的思想里面，把功能分为核心业务功能，和周边功能。

• 所谓的核心业务，比如登陆，增加数据，删除数据都叫核心业务
• 所谓的周边功能，比如性能统计，日志，事务管理等等

周边功能在 spring 的面向切面编程aop思想里，即被定义为切面

在面向切面编程aop的思想里面，核心业务功能和切面功能分别独立进行开发，然后把切面功能和核心业务功能 "编织" 在一起，这就叫aop

aop 的目的

aop能够将那些与业务无关，却为业务模块所共同调用的逻辑或责任（例如事务处理、日志管理、权限控制等）封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可拓展性和可维护性。

aop 当中的概念：

• 切入点（pointcut）
  在哪些类，哪些方法上切入（where）
• 通知（advice）
  在方法执行的什么实际（when:方法前/方法后/方法前后）做什么（what:增强的功能）
• 切面（aspect）
  切面 = 切入点 + 通知，通俗点就是：在什么时机，什么地方，做什么增强！
• 织入（weaving）
  把切面加入到对象，并创建出代理对象的过程。（由 spring 来完成）

aop 编程

1. 在 packge【service】下创建 【productservice】类：

package service;

public class productservice {
    public void dosomeservice(){
        system.out.println("dosomeservice");
    }
}

1. 在 xml 文件中装配该 bean：

<bean name="productservice" class="service.productservice" />

1. 在【testspring】中编写测试代码，运行：

1. 在 packge【aspect】下准备日志切面 【loggeraspect】类：

package aspect;

import org.aspectj.lang.proceedingjoinpoint;

public class loggeraspect {
    
    public object log(proceedingjoinpoint joinpoint) throws throwable {
        system.out.println("start log:" + joinpoint.getsignature().getname());
        object object = joinpoint.proceed();
        system.out.println("end log:" + joinpoint.getsignature().getname());
        return object;
    }
}

1. 在 xml 文件中声明业务对象和日志切面：

<?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:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemalocation="
   http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/aop
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
   http://www.springframework.org/schema/tx
   http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

    <bean name="productservice" class="service.productservice" />
    <bean id="loggeraspect" class="aspect.loggeraspect"/>

    <!-- 配置aop -->
    <aop:config>
        <!-- where：在哪些地方（包.类.方法）做增加 -->
        <aop:pointcut id="loggercutpoint"
                      expression="execution(* service.productservice.*(..)) "/>

        <!-- what:做什么增强 -->
        <aop:aspect id="logaspect" ref="loggeraspect">
            <!-- when:在什么时机（方法前/后/前后） -->
            <aop:around pointcut-ref="loggercutpoint" method="log"/>
        </aop:aspect>
    </aop:config>
</beans>

1. 再次运行 testspring 中的测试代码，代码并没有改变，但是在业务方法运行之前和运行之后，都分别输出了日志信息：

欢迎转载，转载请注明出处！
简书id：
github：
欢迎关注公众微信号：
分享自己的文娱和互联网编程知识

如对本文有疑问， 点击进行留言回复！！