【一头扎进Spring】 01 | 从 HelloWorld 开始看Spring

时间  2020-01-23
标签 一头扎进Spring helloworld 开始 spring 栏目 Spring 繁體版
原文   原文链接
  • Spring 是一个开源框架.
  • Spring 为简化企业级应用开发而生. 使用 Spring 可使简单的 JavaBean 实现之前只有 EJB 才能实现的功能.
  • Spring 是一个 IOC(DI) 和 AOP 容器框架.

    开发环境
  • 开发工具： IDEA
  • JDK 8.0
  • Spring 4.0

Spring 的简单介绍

spring-xmind
具体描述 Spring:java

  • 轻量级：Spring 是非侵入性的 - 基于 Spring 开发的应用中的对象能够不依赖于 Spring 的 API
  • 依赖注入(DI --- dependency injection、IOC)
  • 面向切面编程(AOP --- aspect oriented programming)
  • 容器: Spring 是一个容器, 由于它包含而且管理应用对象的生命周期
  • 框架: Spring 实现了使用简单的组件配置组合成一个复杂的应用. 在 Spring 中可使用 XML 和 Java 注解组合这些对象
  • 一站式：在 IOC 和 AOP 的基础上能够整合各类企业应用的开源框架和优秀的第三方类库 （实际上 Spring 自身也提供了展示层的 SpringMVC 和 持久层的 Spring JDBC）

Spring 模块

spring-model

核心容器(Core Container) 包括Core、Beans、Context、EL模块web

  1. Core和Beans模块提供了Spring最基础的功能，提供IoC和依赖注入特性。这里的基础概念是BeanFactory，它提供对Factory模式的经典实现来消除对程序性单例模式的须要，并真正地容许你从程序逻辑中分离出依赖关系和配置。
  2. Context模块基于Core和Beans来构建，它提供了用一种框架风格的方式来访问对象，有些像JNDI注册表。Context封装包继承了beans包的功能，还增长了国际化（I18N）,事件传播，资源装载，以及透明建立上下文，例如经过servlet容器，以及对大量JavaEE特性的支持，如EJB、JMX。核心接口是ApplicationContext。
  3. Expression Language，表达式语言模块，提供了在运行期间查询和操做对象图的强大能力。支持访问和修改属性值，方法调用，支持访问及修改数组、容器和索引器，命名变量，支持算数和逻辑运算，支持从Spring 容器获取Bean，它也支持列表投影、选择和通常的列表聚合等。

数据访问/集成部分(Data Access/Integration)spring

  1. JDBC模块，提供对JDBC的抽象，它可消除冗长的JDBC编码和解析数据库厂商特有的错误代码。
  2. ORM模块，提供了经常使用的"对象/关系"映射APIs的集成层。 其中包括JPA、JDO、Hibernate 和 iBatis 。利用ORM封装包，能够混合使用全部Spring提供的特性进行"对象/关系"映射，如简单声明性 事务管理 。
  3. OXM模块，提供一个支持Object和XML进行映射的抽象层，其中包括JAXB、Castor、XMLBeans、JiBX和XStream。
  4. JMS模块，提供一套"消息生产者、消费者"模板用于更加简单的使用JMS，JMS用于用于在两个应用程序之间，或分布式系统中发送消息，进行异步通讯。
  5. Transaction模块，支持程序经过简单声明性 事务管理，只要是Spring管理对象都能获得Spring管理事务的好处，即便是POJO，也能够为他们提供事务。

Webshell

  1. Web模块，提供了基础的web功能。例如多文件上传、集成IoC容器、远程过程访问、以及Web Service支持，并提供一个RestTemplate类来提供方便的Restful services访问
  2. Web-Servlet模块，提供了Web应用的Model-View-Controller（MVC）实现。Spring MVC框架提供了基于注解的请求资源注入、更简单的数据绑定、数据验证等及一套很是易用的JSP标签，彻底无缝与Spring其余技术协做。
  3. Web-Struts模块， 提供了对Struts集成的支持，这个功能在Spring3.0里面已经不推荐了，建议你迁移应用到使用Struts2.0或Spring的MVC。
  4. Web-Portlet模块，提供了在Portlet环境下的MVC实现

AOP数据库

  1. AOP模块，提供了符合AOP 联盟规范的面向方面的编程实现，让你能够定义如方法拦截器和切入点，从逻辑上讲，能够减弱代码的功能耦合，清晰的被分离开。并且，利用源码级的元数据功能，还能够将各类行为信息合并到你的代码中 。
  2. Aspects模块，提供了对AspectJ的集成。
  3. Instrumentation模块， 提供一些类级的工具支持和ClassLoader级的实现，能够在一些特定的应用服务器中使用。

Test编程

  1. Test模块，提供对使用JUnit和TestNG来测试Spring组件的支持，它提供一致的ApplicationContexts并缓存这些上下文，它还能提供一些mock对象，使得你能够独立的测试代码。

HelloWorld

首先建立一个 Maven 工程（也可使用IDEA里面的那个 Spring . 这里初学，就不建议使用那个了。一样，建议建立 maven 工程，方便 Jar 包的管理）；Maven工程你们就能够本身建立一个空白的 工程就行。数组

建立好咱们的 Maven 工程后，咱们须要配置好咱们的 pom.xml 文件，引入咱们的开发包。缓存

<dependencies>
        <!-- Spring Core-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- Spring Context-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- Spring Beans-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- Spring Web-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- Spring WebMvc-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- Spring Aop-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>
    </dependencies>

咱们的父工程的搭建好了以后，就开始建立咱们的子工程。我这取名： spring-learning-quickstart.子工程是继承父工程的，这样咱们就不用再次导入咱们的开发包了。服务器

咱们在 子工程中建立一个 bean , 取名 HelloWorld .mvc

public class HelloWorld {
    private String name ;
    public void setName(String name) {
        this.name = name;
    }
    public void sayHello(){
        System.out.println("Hello " + name);
    }
    public HelloWorld() {
        System.out.println("Constructor for HelloWorld");
    }
}

而后，咱们在建立一个主类 Main .

public class Main {
    public static void main(String[] args) {
        // 传统作法( 这不是Spring 的作法)
        HelloWorld helloWorld = new HelloWorld();
        helloWorld.setName("Spring");
        helloWorld.sayHello();
    }
}

一运行，咱们就能够看到控制台出现了：

hello Spring

固然，这个不是 Spring 的方式。如今咱们来看看 Spring 中怎么去作。

Spring 实现

在Spring 中，咱们须要经过配置去实现咱们的这个 HelloWorld 的。首先，咱们在 resource 中新建一个 XML 的文件 。 我这就叫 applicationContext.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- 配置Bean -->
    <bean id="helloWorld" class="com.spring.bean.HelloWorld">
        <property name="name" value="SunYang's Spring"></property>
    </bean>
</beans>

这里稍后在解释。

而后咱们在主类中，这么来写。

//1 建立 Spring 的 IOC 容器对象
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        //2 从IOC 容器中获取 Bean 实例
        HelloWorld hello = (HelloWorld)applicationContext.getBean("helloWorld");
        //3 调用 sayHello()
        hello.sayHello();

这样咱们的控制台就出现：

hello SunYang's Spring

如今呢，先来看一下，Spring建立了这个容器的过程当中帮咱们作了什么。咱们在这个容器建立这边打一个断点。
spring-helloworld
而后程序执行到这之后，会自动跳到咱们的 HelloWorld 类里面，在看这个：
spring-helloworld-name
咱们能够看到，这个时候Spring就已经把 SunYang's Spring 给了 name 了。

Spring 核心

两个重点概念

  • IOC: 控制反转，与依赖注入 DI 同样
  • AOP： 面向切面编程

IOC

所谓控制反转，实际上是一个由主动转被动的一个过程。举个例子：

以前，咱们没有饮品店的时候，咱们想喝果汁了，就是本身准备水果，而后本身榨果汁。这就是一个主动的创造一杯果汁的过程。可是，如今有饮品店了，咱们想喝果汁了，咱们就不在须要本身去榨一杯果汁，而是叫饮品店去榨一杯果汁，请注意，这里咱们并无创造一杯果汁，可是依然达到了咱们要喝果汁的目的。这边是控制反转的思想。好比说：
我如今要喝 一个 大杯的三分糖的橙子汁。

/**
     * 咱们要喝的水果汁
     * @param water 果汁加的水
     * @param fruit 水果类型
     * @param sugar 糖
     * @return
     */
    public static String juiceMix(String water , String fruit ,String sugar){
        String juice = String.format("我要喝 %s 的 , %s 的 %s" , water ,sugar ,fruit ) ;
        return juice ;
    }

如今咱们有了要喝的果汁，如今就是须要有人去作，至关于一个店家去作。

public class JuiceProduce {

    private String water ;
    private String fruit ;
    private String sugar ;

    public void setWater(String water) {
        this.water = water;
        System.out.println(this.water);
    }

    public void setFruit(String fruit) {
        this.fruit = fruit;
    }

    public void setSugar(String sugar) {
        this.sugar = sugar;
    }

    public JuiceProduce() {
        System.out.println("Constructor for JuiceProduce");
    }

    public String juiceProduce(){
        return Blende.juiceMix(this.water , this.fruit , this.sugar) ;
    }
}

如今咱们须要选择那家店去喝这个果汁了，就是在 配置文件里面去配置一下。

<bean id="juiceProduce" class="com.spring.bean.JuiceProduce">
        <property name="water" value="大杯" />
        <property name="fruit" value="橙汁" />
        <property name="sugar" value="三分糖"/>
    </bean>

咱们选择这个名叫 juiceProduce 的店家来制造咱们的果汁。最后的结果就是:

我要喝 大杯 的 , 三分糖 的 橙汁

在下一篇中，讲一下这个关于 Bean 的配置问题。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程