Spring hello world

什么是spring

spring是一个开源的,轻量级java开发框架; 其核心特性是可以用于开发任何 java 应用程序,spring 框架的目标是使 javaee应用程序的开发变得更加容易,核心概念是ioc和aop;这也是学习spring的重点所在;

spring不是针对某个具体功能,具体层级的框架; 也就是说以前该有的系统分层,结构,设计模式都不需要改变,而是让spring加入进来,让开发变得更简单; 记住spring并不想取代某个已存在的框架,反而可以让各个框架的配合使用难度降低,它就像502胶水,可快速的在系统中集成其他优秀的框架

spring也因其特性而得名,寓意为javaee开发的春天来了

为什么需要spring

我们经常会看到spring替代ejb,或spring与ejb对比等等相关文章,那么两者之间到底有什么关系呢?

之前的课程中我们知道,ejb是javaee规范中的一个,主要用于开发分布式应用程序

从概念上来看:

• spring是一个框了架,框架是帮你实现了一部分功能的半成品
• 而ejb是一个规范,用来规范(指导)开发者,如何去实现javaee程序

所以这个问题其实是在问spring(框架)和javaee(规范)的对比,而因为两者不是同一种概念,所以无法直接对比,那到底在对比啥? 不能在卖关子了;

问题应该是:使用spring开发和完全按照javaee规范开发应用程序的区别

这个问题应该由spring的作者rod johnson来回答:

#rod johnson在2002年编写的《expert one-to-one j2ee design and development》一书，rod 在本书中对j2ee正统框架臃肿、低效、脱离现实的种种学院派做法提出了质疑，并以此书为指导思想，编写了interface21框架，也就是后来的spring。

的确推出spring推出就是民间开发者对官方规范的中不足的地方提出的质疑以及做出的强力回应,在早期阶段,开发者们经历了拥抱到抛弃,从最早的javaee这一官方协议推出后,开发者们非常拥戴,毕竟是官方嘛,后来慢慢发现这堆复杂,晦涩,学习成本极高的规范是多么的臃肿不堪,就像你为了打一只小鸟而搬出了战斗机;就在这时候spring框架应运而生,因其轻量级,使用简单很快受到了大家的喜爱;

好在官方也意识到了问题,于是在ejb3.0做出了大量的改进,并借鉴了spring中一些非常优秀的特性,但如日中天的spring好像并没有受到太大的影响,大家一如既往的喜爱spring;

ejb容器ioc容器

另一方面因为spring具备ico容器,可以帮助我们管理bean,而ejb的需要放在ejb容器中才能使用其提供的功能; ejb主要用于提供分布式能力,而ioc容器是帮助我们更好的解耦

spring的优点

• spring 对javaee中的一些api(jdbc、javamail、远程调用等),提供了封装,使这些api使用难度降低;
• 一站式框架,可简单快速的集成其他框架;
• ioc,利用依赖注入,极大的降低各组件间的耦合,提高整体扩展性;
• aop(面向切面)编程的支持,可以方便的对程序进行权限拦截,运行监控等;
• 声明式事务支持,通过配置就可以完成对事务的管理,无序进行手动编程;
• 容器化,spring包含并管理应用对象的配置和生命周期,你可以配置每个bean如何被创建以及bean是一个单独的实例或者每次需要时都生成一个新的实例,以及它们是如何相互关联的。

ioc,di

概念

控制反转（inversion of control，缩写为ioc），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。

将原本由程序实现的一部分逻辑反过来交给系统来完成就称之为控制反转

其中最常见的方式叫做依赖注入（dependency injection，简称di）通过控制反转，可以说，依赖被注入到对象中。

依赖注入是实现控制反转的一种手段;

为何需要ioc

举个例子:自己搭配组装机,需要考虑各种部件的兼容性,和自己的性能的要求,如cpu,内存,显卡等等;但有了专门的组装机服务器商(ioc容器),你只要告诉他你的基本需求,比如,要一台吃鸡电脑,剩下的就交给服务商去做了;

大多数应用程序,都是有很多不同对象彼此合作来完成业务逻辑,这导致在获取一个合作对象时,必须显示的去new一个对象,这将就导致代码高度耦合并且难以维护和调试。像下面这样

public class controller {
    @test
    public void doget() throws exception {
        //这里需要依赖service层
        userservice service = new userservice("参数1","参数2");
    }

当需要更换其他业务逻辑实现类时就不得不修改源代码,并且若service的实例化需要参数时,controller层就不得不为其提供必要的参数,这反映了controller与service的耦合度是较高的

spring体系结构

core,提供了框架基础组成部分,包括ioc和di;

beans,提供了beanfactory,是工厂模式的实现,提供普通对象和单例对象的获取

context,建立在core和bean的基础上,可将其他库集成到spring中

spel(spring-expression language)提供了表达式语言支持,其对jsp中的el进行了扩展

aop,提供了面向切面编程实现

aspects 模块提供了与 aspectj 的集成,是一个功能强大且成熟的aop框架

instrumentation 用于代理监控jvm运行的java程序,对字节码修改以实现aop

messaging 模块为 stomp 提供了支持,主要处理来自 websocket 客户端的 stomp 信息

强调:

spring是模块化的,完全可以根据需要来导入所需模块

使用入门

传统写法

先来看一个不使用spring时,控制和业务逻辑层交互的案例,控制器:

public class controller {

    @test
    public void doget() throws exception {
        //这里需要依赖service层

        //v1 直接写
        //userservice service = new userservice();

        //v2 面向接口 某个实现类
        //userservice service = new userserviceimpl();
        //要跟换其他实现类时  违反了ocp(开放封闭)原则
        //userservice service = new userserviceimpl2();

        //v3 为避免修改源代码扩展 加入工厂
        servicefactory factory = new servicefactory();
        userservice service = factory.getservice();

        //调用业务方法
        service.userlogin("jerry","admin");
    }
}

工厂:

public class servicefactory {
    public userservice getservice() throws exception {
        //此处id应配置在xml中
        string id = "userserviceimpl";
        if (id.equals("userserviceimpl")){
            return new userserviceimpl();
        }else if(id.equals("userserviceimpl2")){
            return new userserviceimpl2();
        }
        throw new exception("id:"+id + "not register");
    }
}

使用工厂模式可以进一步降低组件间的耦合度,但在完整的系统中有很多组件,需要很多个工厂,使程序变得复杂,臃肿;

spring将自身设计为一个大型对象工厂,负责管理系统中设计到的所有对象,并利用di处理对象的依赖关系,当对象a需要对象b时不再自己创建而是从spring中获取

补充说明:ocp

叫做开放封闭原则,是应用程序开发中应该遵循的一个原则

open:对扩展开放

close:对修改源代码封闭

其目的是要在不修改源代码的情况下对已有功能进行扩展

使用spring

1.创建maven项目

2.添加依赖

<dependency>
  <groupid>org.springframework</groupid>
  <artifactid>spring-context</artifactid>
  <version>5.2.2.release</version>
</dependency>
<!-- maven会自动下载所有spring核心容器和aop的依赖-->

3.创建配置文件

通常名为:applicationcontext.xml当然你也可以修改放在resources下

<?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
https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--使用bean标签，创建service对象，并交给容器来管理-->
    <bean id="userservice1" class="com.yyh.serviceimpl.userserviceimpl"/>
    <bean id="userservice2" class="com.yyh.serviceimpl.userserviceimpl2"/>
</beans>

名称空间声明可到官网查找,或是直接在jar中查找,如:

4.从spring中获取需要的对象

    @test
    public void dogetusespring() throws exception {
        //创建应用上下文 指定配置文件
        applicationcontext context = new classpathxmlapplicationcontext("applicationcontext.xml");
          //从spring中获取所需对象
        userservice userservice = (userservice)context.getbean("userservice2");
        //调用业务逻辑方法
        userservice.userlogin("jerry","admin");
    }

不难看出此时的spring就是一个对象工厂,但这仅仅spring的基础功能

ioc容器

容器可以理解为存放对象的地方,当然不仅仅是存储,还有对象的管理,包括-创建-销毁-装配; 这样原本程序要做的事情交给了spring,所以这属于ioc,称之为ioc容器;

spring有两个接口applicationcontext是beanfactory的子接口。它们都可以作为spring的容器;

两种容器的区别:

• beanfactory作为*接口主要面向于spring框架本身,仅提供了基础基本的容器功能如di

• applicationcontext,是beanfactory的子接口,意味着功能比beanfactory更多,诸如国际化,注解配置,xml配置等等,因此applicationcontext使用更多
  • applicationcontext的两个实现类区别:
  • classpath表示从类路径中获取配置文件,
  • filesystem表示从文件系统获取配置文件
• beanfactory采取的懒加载的方式,在获取对象时才会实例化

• applicationcontext会在工厂初始化时立即实例化对象