【阅读笔记】《Java EE企业应用实战》（第四版）第七章——Spring的基本用法

Spring的定义和相关知识点

Spring包括

  • 基于依赖注入的核心机制（再也不用new一个对象啦）
  • 基于AOP的声明式事物管理
  • 与多种持久层技术的整合
  • Web MVC框架

Spring的优点

  • 低侵入式设计，代码污染低
  • 独立于各种应用服务器，基于Spring框架的应用，可以真正实现Write Once,Run Anywhere的承诺（合着以前Java说的Write Once,Run Anywhere到了这里才能实现呀）
  • Spring的IoC容器降低了业务对象替换的复杂性，提高了组件之间的解耦。
  • Spring的AOP支持允许将一些通用任务如安全、事物、日志等进行集中式处理， 从而提供了更好地复用
  • Spring的ORM和DAO提供了与第三方持久层框l架的良好整合，并简化了底层的数据结构访问。
  • Spring的高度开放性，并不强制应用完全依赖于Spring，开发者可以自由选用Spring框架的部分或全部。

Spring的搭建和一个小例子

下载和使用

本篇以Spring4.3为例，在Java EE - Eclipse中使用

先选择要下载的版本，之后进去选择那个最大的文件下载，在这里就是spring-framework-4.3.0.RELEASE-dist.zip

下载地址

之后在解压出来的文件夹在spring-framework-4.3.0.RELEASE\libs中的所有jar文件拷贝到项目文件中的WebContent/WEB_INF/lib文件夹中（之后可以在Java Resources/Web App Library中设置一下doc和源代码的设置，我这里就不写了）之后在Web App Libraries中可以看到如下的内容

这样我们就做好了一个Spring的环境了，之后还要有commons-logging的jar包，在网上搜索commons-logging-1.2.jar下载下来之后粘贴到lib文件夹里就好，接下来我们做一个小示例说明一下

小示例

首先我们写一个Animat动物接口，里面有say和move方法来表示动物都有的发声和移动行为，如下:

package com.impl;
public interface Animal {
    /**
     * 动物发出声音的方法
     * @return
     */
    public String say();

    /**
     * 动物移动的方法
     * @return
     */
    public String move();
}

之后写两个这个接口的实现类Cat和Dog

Cat.java

package com.entity;

import com.impl.Animal;

public class Cat implements Animal {

    @Override
    public String say() {
        // TODO Auto-generated method stub
        return "喵喵喵";
    }

    @Override
    public String move() {
        // TODO Auto-generated method stub
        return "小猫咪脚步静悄悄的";
    }

}

Dog.java

package com.entity;

import com.impl.Animal;

public class Dog implements Animal {

    @Override
    public String say() {
        // TODO Auto-generated method stub
        return "汪汪汪";
    }

    @Override
    public String move() {
        // TODO Auto-generated method stub
        return "小狗跑得很欢快";
    }

}

写好这两个动物的实现类之后我们再写一个Person类，来代表人，每个人都有一个动物这个动物可以是猫也可以是狗

Person.java

package com.entity;

import com.impl.Animal;

public class Person {
    private String name;
    private Animal animal;
    public Animal getAnimal() {
        return animal;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setAnimal(Animal animal) {
        this.animal = animal;
    }
}

在以前如果我们要指定这个人有一只狗会这样写

Person person = new Person();
Cat cat = new Cat();
person.setAnimal(cat);
person.setName("王小明");

这样做会在代码里面写死，日后要修改的就比较麻烦了，如果使用Spring的话就不一样了，使用Spring的时候要在src文件夹下新建一个xml文件，这个文件的名字一般叫做beans.xml，我们再这个文件里面配置各种JavaBean，在这个例子中我们的beans.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:c="http://www.springframework.org/schema/c"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:util="http://www.springframework.org/schema/util"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/util
        http://www.springframework.org/schema/util/spring-util-4.0.xsd">
    <!-- 创建一个叫做cat的bean，它所对应的class是com.entity.Cat -->
    <bean id="cat" class="com.entity.Cat"/>
    <!-- 同上 -->
    <bean id="dog" class="com.entity.Dog"/>
    <!-- 创建一个叫做person的bean，它所对应的class是com.entity.Person -->
    <bean id="person" class="com.entity.Person">
        <!-- 设置person这个bean中的animal参数的值是cat这个JavaBean -->
        <property name="animal" ref="cat"/>
        <!-- 设置person这个bena中name参数是‘王小明‘ -->
        <property name="name" value="王小明"/>
    </bean>
</beans>

这样我们就把一只猫和一个人相关联起来了，还把人的名字设置成了”王小明”，现在我们来测试一下，测试代码可以这样写

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
Person person = applicationContext.getBean("person", Person.class);
System.out.println("我叫" + person.getName());
System.out.println("我的宠物叫:" + person.getAnimal().say());
System.out.println("我的宠物移动:" + person.getAnimal().move());

我们通过ApplicationContext 来找到是哪个bean的，ClassPathXmlApplicationContext方法中的参数就是在src文件夹下配置bean的那个xml文件的名字，获取了ApplicationContext 之后可以通过bean的id找到这个bean了。这样做的好处就是我如果要把狗狗赋给人的话只需要在xml配置文件中把改成就可以了，而且我这里没有配置bean所以默认都是单例模式，这样在请求多个同样class的bean获取到的bean都是同一个bean，系统不需要再去new一个bean了节约了系统的开销。

关于依赖注入

在上个例子中盘person并没有对animal成员变量进行设置，但是还是可以获取得到person的animal的值并可以调用animal的say方法，这是由于使用了Spring来配置bean才能实现这样的效果的，使用这种方法需要在Person类中有setAnimal()方法。

之后我们在beans.xml中配置了这个bean的相关参数之后就会自动调用setAnimal方法，这是一种比较好的解耦方式。依赖注入让Spring的Bean以配置文件组织在一起，而不是以硬编码的方式耦合在一起。

由此可见，Spring的核心功能有两个

* Spring容器作为超级大工厂，负责创建、管理所有的Java对象，这样Java对象被称为Bean。

* Spring容器管理容器中Bean之间的依赖关系，Spring使用一种被称为“依赖注入”的方式来管理Bean直接的依赖关系。

获取对象的方式

  • 原始做法通过new关键字创建对象，这种方法需要在代码中创建对象，必然导致调用者与被依赖的对象实现类的硬编码耦合:new Person();
  • 简单的工厂模式，这种方式需要注意三点:①调用者需要面向依赖对象的接口编程②将被依赖的对象的创建交给工程完成③电泳者通过工程来获取被依赖组件:Person = person PersonFactory.create();
  • 使用Spring，调用者无需主动获取被依赖的对象，调用者只需要被动接受Spring容器为调用者的成员变量赋值即可。applicationContext.getBean(“person”, Person.class)

关于依赖注入和控制反转——其实两者是一样的

控制反转是指调用者获取被依赖对象的方式由原来的主动获取编程了被动接受，而依赖注入是指Spring容器负责将依赖对象赋值给调用者的成员变量——相当于为调用者注入它依赖的实例。所以可见依赖注入和控制反转是同一件事情只不过控制反转是以调用者的角度去描述，而依赖注入是以Spring容易的角度去描述的。

在这里李刚老师做了一个很生动的例子

* 原始社会里，几乎没有劳动分工，需要斧头的人（调用者）这股本报告自己去做一把斧头（被依赖对象）。对应的情形为：Java程序里的调用者自己创建依赖对象，通常采用new关键字调用构造器创建一个被依赖对象。这样的缺点有两点：①可拓展性差，由于“人”组件与“斧头”组件的实现类高度耦合，当程序试图拓展斧头组件时，“人”组件的代码也要随之改变。②各组件职责不清。对于“人”而言他只需要调用“斧头”组件的方法即可，并不关心“斧头”组件的创建过程。但是在这种模式下，“人”组件却需要主动创建“斧头”组件，因此职责混乱。

* 工业社会，工程出现了，斧头不再由普通人完成，而在工厂里面被生产出来，此时需要斧头的人（调用者）找到工厂，购买斧头，无需关心斧头的制造过程。对应简单工厂模式，调用者祝需要定位工厂，无需理会被依赖对象的具体实现过程。这种方法虽然实现了调用者和被依赖对象的实现类解耦，但是调用者依然需要主动定位工厂，调用者和工厂耦合在一起。

* 共产社会，需要斧头的人甚至无需定位工厂，“坐等”社会提供即可。调用者无须关心被依赖的对象的实现，无需理会工厂，等待Spring依赖注入。

设值注入

    <!-- 创建一个叫做person的bean，它所对应的class是com.entity.Person -->
    <bean id="person" class="com.entity.Person">
        <!-- 设置person这个bean中的animal参数的值是cat这个JavaBean -->
        <property name="animal" ref="cat"/>
        <!-- 设置person这个bena中name参数是‘王小明‘ -->
        <property name="name" value="王小明"/>
    </bean>

构造注入

    <bean id="person" class="com.entity.Person">
        <constructor-arg name="name" value="张三"/>
        <constructor-arg ref="dog" name="animal"/>
    </bean>

使用这个构造注入的时候要在Person类中有一个接收String和Animal参数的构造函数。

两种构造方式的对比

  • 设值注入与传统的JavaBean的写法更相似，更容易让开发者理解
  • 对于复杂的依赖关系，如果采用构造注入会显得构造器比较臃肿。Spring在创建Bean实例时需要同时实例化其他依赖的全部实例，因而导致性能下降。而使用设置注入则能避免这些问题。
  • 在成员变量可选的情况下，多参数的构造器如果要使用构造注入的话可能会比较麻烦。
  • 构造注入可以在构造器中决定依赖关系的注入顺序。
  • 对于依赖关系无须变化的Bean，构造注入更有用处。因为没有setter方法，所有的依赖关系全部在构造器内部设定。因此，无须担心后续的代码对依赖关系产生破坏。
  • 在构造注入中依赖关系只能在构造器中设定，只有组件的创建者才能改变组件的依赖关系。对组件的调用者而言，组件内部的依赖关系完全透明，更符合高内聚的原则。

Spring的相关使用

事件机制

Spring的世界框架有两个重要成员

* ApplicationEvent：容器事件，必须由ApplicationContext发布。

* ApplicationListener：监听器，可由容器中的任何Bean担任

使用的时候ApplicationEvent的子类在构造函数中加入Object类型的一个参数，然后再方法体里面加上super(object)即可。

ApplicationListener的实现类需可以添加onApplicationEvent(ApplicationEvent evt)方法，对evt的类型进行判断如果是指定的类型就可以添加代码在这个项目运行之前运行，有点像拦截器。

让bean获取Spring容器

一般都是用Spring容器来创建bean，那bean有没有办法获取创建它的bean呢？具体的方法就是在bean中实现ApplicationContextAware接口，之后实现setApplicationContext，那么在创建这个bean的时候就可以在这个方法中获取到创建它的bean

    @Override
    public void setApplicationContext(ApplicationContext arg0) throws BeansException {
        // TODO Auto-generated method stub
        System.out.println("获取到创建bean的ApplicationContext了:" + arg0.getDisplayName());
    }

bean的别名

在配置bean的时候需要指定id和class，分别代表着这个bean的唯一标识和所对应的具体实现类。我们还可以指定name属性（或者使用alias标签），这个属性就是bean的别名，例如

<bean id="cat" class="com.entity.Cat" name="spirit"/>

那么cat的别名就设置成了spirit了，这时我们对person创建与cat的依赖的时候就可以这样设置

    <bean id="person" class="com.entity.Person">
        <constructor-arg name="name" value="张三"/>
        <constructor-arg ref="spirit" name="animal"/>
    </bean>

如果一个bean要同时指定多个别名的话可以使用英文逗号、冒号或者空格分隔

bean的作用域

可以在bean标签中对scope属性进行设置，常用的作用域有5种

* singleton：单例模式，在整个Spring IoC容器中，singleton作用域的Bean将只生成一个实例。

* prototype：每次通过容器的getBean()方法获取prototype的bean都是一个新的bean实例。

* request：对于一次HTTP请求，request的作用域的bean将只生成一个实例。这意味着，在同一次HTTP请求内，程序每次请求该bean时，得到的总是同一个实例。这有在Web应用中使用Spring是，该作用域才会真正有效。

* session：类似于request，只不过是在同一个session会话中请求的bean都是同一个。

* global session：每个全局的HTTP Session对应一个bean实例。在典型状态下，仅使用portlet context的时候才有效。同样只有在Web应用中才有效

使用prototype创建的bean在创建完成之后Spring就不再跟踪实例，也不会维护bean的状态。

如果不指定bean的状态，那么默认是singleton，这种作用域在创建之后可以重复利用，可以减少系统的开销。应该尽量使用singleton。

注入集合

举个例子

MyList.java这个bean

package com.entity;

import java.util.List;
import java.util.Map;

public class MyList {
    private List<String> lists;
    private Map<String, String> maps;
    public List<String> getLists() {
        return lists;
    }
    public void setLists(List<String> lists) {
        this.lists = lists;
    }
    public Map<String, String> getMaps() {
        return maps;
    }
    public void setMaps(Map<String, String> maps) {
        this.maps = maps;
    }

}

之后在beans.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:c="http://www.springframework.org/schema/c"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:util="http://www.springframework.org/schema/util"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/util
        http://www.springframework.org/schema/util/spring-util-4.0.xsd">
    <!-- 使用p的XML Schema简化配置 -->
    <!-- p:lists是指MyList这个类中的lists的值是my.lists的值 -->
    <bean id="myList" class="com.entity.MyList"
        p:lists-ref="my.lists"
        p:maps-ref="my.maps"
    />
    <util:list id="my.lists" list-class="java.util.ArrayList">
        <value>星期一</value>
        <value>星期二</value>
        <value>星期三</value>
    </util:list>
    <util:map id="my.maps" map-class="java.util.HashMap">
        <entry key="晴天" value="去郊游"/>
        <entry key="雨天" value="去看书"/>
        <entry key="阴天" value="收拾房间"/>
    </util:map>
</beans>

测试方法

        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
        MyList myList = applicationContext.getBean("myList", MyList.class);
        System.out.println("lists=" + myList.getLists());
        System.out.println("maps=" + myList.getMaps());

这样就可以为list和map赋值了，与之类似的是util:set来配置Set

Spring的表达式语言SpEL

（我还没怎么接触，先不写这个）

时间： 2024-10-26 14:16:11

【阅读笔记】《Java EE企业应用实战》（第四版）第七章——Spring的基本用法的相关文章

轻量级Java EE企业应用实战（第4版）：Struts 2+Spring 4+Hibernate整合开发(含CD光盘1张)

轻量级Java EE企业应用实战(第4版):Struts 2+Spring 4+Hibernate整合开发(含CD光盘1张)(国家级奖项获奖作品升级版,四版累计印刷27次发行量超10万册的轻量级Java EE经典著作) 李刚 编著   ISBN 978-7-121-24253-3 2014年10月出版 定价:108.00元 824页 16开 编辑推荐 国内知名IT图书作家李刚老师基于曾荣获中国书刊发行业协会“年度全行业优秀畅销品种”大奖的<轻量级Java EE企业应用实战(第3版)>全新升级:

&lt;轻量级Java EE企业应用实战&gt;2：Struts 2 的基本用法

1 MVC 思想概述 2 Struts 2 的下载和安装 添加 Struts 2 的 jar 到项目 lib 目录,修改 web.xml 文件: <?xml version="1.0" encoding="UTF-8"?> <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-ins

&lt;轻量级Java EE企业应用实战&gt;1：JSP/Servlet及相关技术详解（二）

7 Servlet 介绍 7.1 Servlet 的开发 @WebServlet(name = "helloServlet", urlPatterns = {"/helloServlet"}) public class HelloServlet extends HttpServlet { @Override protected void service(HttpServletRequest req, HttpServletResponse resp) throws

spring实战第四版第五章pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"> <modelVersion&

Java编程思想第四版*第七章*个人练习

练习1:(2)创建一个简单的类.第二个类中,将一个引用定义为第一个类的对象.运用惰性初始化来实例化 这个对象. package test; public class Manager { public static void main(String args[]){ Second s=new Second(); s.getFirst(); } /** * 打印结果: */ } class First{ } class Second{ First f; Second(){ System.out.pr

SSH:Struts + Spring + Hibernate 轻量级Java EE企业框架

Java EE(Java Platform,Enterprise Edition)是sun公司(2009年4月20日甲骨文将其收购)推出的企业级应用程序版本.这个版本以前称为 J2EE.能够帮助我们开发和部署可移植.健壮.可伸缩且安全的服务器端Java应用程序.Java EE 是在 Java SE 的基础上构建的,它提供Web 服务.组件模型.管理和通信 API,可以用来实现企业级的面向服务体系结构(service-oriented architecture,SOA)和 Web 2.0应用程序.

Java RESTful Web Service实战(第2版)pdf

下载地址:网盘下载 内容简介 本书系统.深度讲解了如何基于Java标准规范实现REST风格的Web服务,由拥有10余年开发经验的阿里云大数据架构师撰写,第1版上市后广获赞誉,成为该领域的畅销书.第2版对全书进行了优化和重构,不仅根据*的技术版本对原有过时内容进行了更新,而且还根据整个技术领域的发展增添了新的内容.除此之外,还对第1版中存在的不足进行了优化,使得内容更加与时具进.更加有价值.不仅深刻解读了*的JAX-RS标准和其API设计,以及Jersey的使用要点和实现原理,还系统讲解了REST

『Java编程思想-第四版』第二章:一切都是对象

Java编程思想-第四版学习总结,此为第二章:一切都是对象. package com.w3cjava.second; @SuppressWarnings("all") public class Second { /** * Java编程思想(第四版) * 第2章 一切都是对象 * @param args */ public static void main(String[] args) { /** * 2.1 用引用操作对象 * 遥控器(引用)操作电视机(对象),改变音量,改变频道 *

《你的灯亮着吗》阅读笔记之第三篇与第四篇

我们平时解决某个问题的时候,是不是也遇到过,用某个方法解决完问题后,是不是又会出现新的问题,新的问题得到解决后是不是又出现了更新的问题,不知道你有没有遇到过,反正我是遇到过,尤其是在敲代码写软件的时候,当你想解决某个输出问题时候,想用某一个控件解决了这个输出问题,但是这个控件放上来后,控件的属性,用法问题又会出现在你的面前,不知道举这个例子是不是很合适啊,权且算是合适吧. 当我们遇到这样问题的时候我们是怎么解决的呢?我们是不是忽视了一些什么?我们有没有回头看看?书中说道:“如果在你对问题的理解中