正文

spring4bak

 2022-03-13  464

关键词：

IOC

（参考《Spring企业开发》、《Spring实战第三版第四版》）

IoC概述

1、 控制反转

2、依赖注入

控制反转：大多数情况下，想要完成一个功能，都需要对象与对象之间相互配合（相互调用）。在最开始的时候，我们都是在哪里需要使用对象，就在哪里new一个对象出来。也就是说，调用者自己维护被调用对象的生命周期。

控制反转的作用，就是将这些对象统一进行初始化，由Spring容器进行管理。并且维护对象之间的关系

依赖注入：如果对象之间存在依赖关系，则由Spring负责将被调用的对象注入到调用对象上。Spring支持构造函数注入和成员变量注入。注入的内容可以是字面值常量、引用。

描述方式：

·怎么将对象纳入Spring管理

1、 XML配置Bean

2、 XML配置扫描，Bean中加合适的注解

3、 Java配置Bean

4、 Java配置扫描，Bean中加合适的注解

·怎么描述对象之间的关系

1、 XML中配置

2、注解

Spring初始化

1、使用Java的Main初始化

2、配置在Web容器中，由容器初始化

简单案例

案例一：XML配置Bean

普通的Bean通过XML配置，交由Spring管理

初始化Spring容器，从容器中获取Bean，执行其方法

需要被管理的Bean

package org.zln.spring4.core.ioc.bean;

/**
* Created by sherry on 16/11/22.
*/
public class HelloWorldBean {
    public String sayHello(String name) {
        return "Hello " + name;
    }
}

Spring配置文件

<?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-4.3.xsd">



    <bean id="helloWorldBean" class="org.zln.spring4.core.ioc.bean.HelloWorldBean"/>



</beans>

Spring初始化并使用容器中的Bean

package org.zln.spring4.core.ioc.bean;



import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;



/**

 * Created by sherry on 16/11/22.

 */

public class SpringMain {



    /**

     * 日志

     */

    private static Logger logger = LoggerFactory.getLogger(SpringMain.class);



    public static void main(String[] args) {

        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

        HelloWorldBean helloWorldBean = (HelloWorldBean) applicationContext.getBean("helloWorldBean");

        logger.debug("Bean执行结果:"+helloWorldBean.sayHello(" ZLN "));



    }



}

案例二：p命名空间注入

在案例一的基础上，使用Spring，通过成员变量注入字面值

HelloWorldBean

package org.zln.spring4.core.ioc.bean;





import org.apache.commons.lang3.StringUtils;



/**

 * Created by sherry on 16/11/22.

 */

public class HelloWorldBean {



    private String name;



    public String getName() {

        return name;

    }



    public void setName(String name) {

        this.name = name;

    }



    public String sayHello(String name) {

        if (StringUtils.isEmpty(name)){

            name = this.name;

        }

        return "Hello " + name;

    }

}

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"

       xmlns:p="http://www.springframework.org/schema/p"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

       http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">



    <bean id="helloWorldBean" class="org.zln.spring4.core.ioc.bean.HelloWorldBean"

          p:name="默认姓名"/>



</beans>

这里使用p命名空间，将字符串字面值注入到了name成员变量上

如果想要注入的是一个引用，则使用 p:name-ref=”id”

案例三：XML配置通过构造函数注入

<bean id="helloWorldBean" class="org.zln.spring4.core.ioc.bean.HelloWorldBean">

    <property name="name" value="默认姓名" />

    <constructor-arg index="0" value="25"/>

</bean>

案例四：Java配置

package org.zln.spring4.core.ioc.bean;



import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;



/**

 * Created by sherry on 16/11/22.

 */

@Configuration

public class ApplicationContextBeans {



    @Bean

    public HelloWorldBean helloWorldBean(){

        HelloWorldBean helloWorldBean = new HelloWorldBean(25);

        helloWorldBean.setName("张柳宁");

        return helloWorldBean;

    }



}

这里的class类，就充当了XML的功能，需要添加 @Configuration 注解

而添加了@bean 的方法，就相当于XML中的bean 标签。默认情况下，Bean的id就是方法名，如果想要另外设置，可以@Bean(“beanName”)这样子进行配置

public static void main(String[] args) {

    ApplicationContext applicationContext = new AnnotationConfigApplicationContext(ApplicationContextBeans.class);

    HelloWorldBean helloWorldBean = applicationContext.getBean(HelloWorldBean.class);

    logger.debug("Bean执行结果:" + helloWorldBean.sayHello(" ZLN "));

    logger.debug("Bean执行结果:" + helloWorldBean.sayHello(""));

    logger.debug(helloWorldBean.toString());

    helloWorldBean = applicationContext.getBean(HelloWorldBean.class);

    logger.debug(helloWorldBean.toString());

}

初始化Java类配置的Bean，需要使用AnnotationConfigApplicationContext

通过两次获取对象并打印来看，获取到的是同一个对象

案例五：使用class对象从Spring容器中获取对象

HelloWorldBean helloWorldBean = applicationContext.getBean(HelloWorldBean.class);

初始化Spring容器

AnnotationConfigApplicationContext/ AnnocactionConfigWebApplicationContext

从一个或多个基于Java的配置类中加载Spring/Spring Web应用上下文

ClassPathXmlApplicationContext

从类路径加载Spring应用上下文

FileSystemXmlApplicationContext

从文件系统加载

XmlWebApplicationContext

从Web应用下加载XML配置文件

Bean的生命周期

传统：从new开始被创建，不再使用后，由垃圾回收器决定什么时候回收

Spring：复杂

1、实例化Bean

2、属性注入

3、设置bean的id

4、设置BeanFactory

5、设置上下文

6、设置Before方法

7、设置init方法

8、设置After方法

9、一直存在上下文中，直到上下文销毁。并调用destory方法

配置Spring的几种方案

XML

Java

扫描

Spring的配置风格是可以互相搭配的

尽量使用扫描的机制，显示配置的越少越好。

XML中配置扫描

<context:component-scan base-package="org.zln.spring4" resource-pattern="**/*Bean"/>

Java中配置扫描

package org.zln.spring4.core.ioc.bean;



import org.springframework.context.annotation.ComponentScan;

import org.springframework.context.annotation.Configuration;



/**

 * Created by sherry on 16/11/22.

 */

@Configuration

@ComponentScan("org.zln.spring4.core.ioc")

public class ApplicationContextBeans {

}

Java中引用XML

package org.zln.spring4.core.ioc.bean;



import org.springframework.context.annotation.ComponentScan;

import org.springframework.context.annotation.Configuration;

import org.springframework.context.annotation.ImportResource;



/**

 * Created by sherry on 16/11/22.

 */

@Configuration

@ComponentScan(basePackages = {"org.zln.spring4.core"},resourcePattern = "**/*Bean.class")

@ImportResource("applicationContext.xml")

public class ApplicationContextConfig {

}

如果在Java中引用Java，就应该使用@Import

XML中引用Java配置

直接将Java配置类像普通Bean一样，使用<bean>标签进行配置即可

如果在XML中引用其他XML配置信息，则使用<import>标签

Spring测试

package org.zln.spring4.core.ioc.bean;



import org.junit.Test;

import org.junit.runner.RunWith;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.test.context.ContextConfiguration;

import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;



import static org.junit.Assert.*;



/**

 * Created by sherry on 16/11/22.

 */

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration(classes = ApplicationContextBeans.class)

public class HelloWorldBeanTest {



    @Autowired

    private HelloWorldBean helloWorldBean;



    /**

     * 日志

     */

    private Logger logger = LoggerFactory.getLogger(HelloWorldBeanTest.class);



    @Test

    public void testSayHello() throws Exception {

        logger.debug(helloWorldBean.sayHello("张柳宁"));

    }

}

环境与profile

同一个bean，在不同环境中，其初始化方式是不一样的

如：数据源，开发、测试、迁移、生产上的配置信息是不一样的。

这个时候就需要根据当前的环境，选择不同的方式进行实例化

Java中配置环境

package org.zln.spring4.core.ioc.bean;



import org.springframework.context.annotation.ComponentScan;

import org.springframework.context.annotation.Configuration;

import org.springframework.context.annotation.ImportResource;

import org.springframework.context.annotation.Profile;



/**

 * Created by sherry on 16/11/22.

 */

//指明这是一个Spring配置类

@Configuration

//扫描路径

@ComponentScan(basePackages = {"org.zln.spring4.core"},resourcePattern = "**/*Bean.class")

//引用的XML配置

@ImportResource("applicationContext.xml")

//进行实例化的环境  dev-开发  prod-生产

@Profile("dev")

public class ApplicationContextConfig {

}

@Profile 也可以配置在Bean上，单独为Bean设置环境

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:p="http://www.springframework.org/schema/p"

       xmlns:context="http://www.springframework.org/schema/context"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

       http://www.springframework.org/schema/beans/spring-beans-4.3.xsd

       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"

       profile="dev">





</beans>

同样的，也可以为每个Bean配置profile属性

激活profile

Spring在确定哪个proof处于激活状态时，需要依赖两个独立的属性 spring.profiles.active 和 spring.profiles.default

如果设置了 spring.profiles.active 就采用 spring.profiles.active，否则就采用spring.profiles.default

如果两个都没设置，那就是说没有激活的profile，那就只会创建没有定义过profile的Bean

那么怎么配置这两个属性呢？

如果是在web中，可以在web.xml中配置DispatchServlet的初始化参数（用init-param配置）或web应用的上下文参数（用context-param配置）



<servlet>

    <servlet-name>webDemo</servlet-name>

    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

    <init-param>

        <param-name>spring.profiles.default</param-name>

        <param-value>dev</param-value>

    </init-param>

</servlet>



<context-param>

    <param-name>spring.profiles.default</param-name>

    <param-value>dev</param-value>

</context-param>

作为JNDI条目

作为环境变量

作为JVM的系统属性

在集成测试类上，使用@ActiveProfiles注解

@ActiveProfiles("dev")

注意：

1、激活的环境的名称是随自己定义的

2、配置的时候可以同时配置激活多个环境

条件化Bean

这是在Spring4开始提供的一种更细粒度的决定是否提供初始化Bean的方案

package org.zln.spring4.core.ioc.bean;



import org.springframework.context.annotation.*;



/**

 * Created by sherry on 16/11/22.

 */

//指明这是一个Spring配置类

@Configuration

//扫描路径

@ComponentScan(basePackages = {"org.zln.spring4.core"},resourcePattern = "**/*Bean.class")

//引用的XML配置

@ImportResource("applicationContext.xml")

public class ApplicationContextConfig {



    @Bean

    @Conditional(value = MagCondition.class)

    public String string(){

        return new String("哇哈哈");

    }



}

package org.zln.spring4.core.ioc.bean;



import org.springframework.context.annotation.Condition;

import org.springframework.context.annotation.ConditionContext;

import org.springframework.core.type.AnnotatedTypeMetadata;



/**

 * Created by sherry on 16/11/22.

 */

public class MagCondition implements Condition {

    @Override

    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {

        return true;

    }

}

如果返回true，就实例化，返回false，就不实例化

可以通过matches方法的两个参数实现很复杂的判断

首选Bean

当在选择哪个Bean进行注入的时候产生了歧义，可以使用首选方案

1、在Bean上配置@Primary

2、在XML中配置 primary=”true”

显然，相同类型只运行有一个Bean配置了Primary

另一种更简单的方式，就是除了使用@Autowired外，还要使用@Qualifier设置依赖的Bean的id

Qualifier也可以与@Bean一同使用，配置在生成Bean的方法上，并且可以设置多个，用于为Bean指定多个名称

Bean的作用域

默认情况下，Spring应用上下文中的Bean都是以单例的形式创建的。

也就是说，不管给定的一个Bean被注入到其他Bean多少次，每次所注入的都是同一个实例

Spring为Bean定义了多种作用域

单例 – Singleton，整个应用中，只创建一个bean实例

原型 – Prototype，每次注入或者通过Spring去获取的时候，都创建一个新实例

会话 – Session，在Web应用中，为每个会话创建一个实例

请求 – Request，在Web应用中，为每个请求创建一个实例

可以在Java中使用

@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)

配置Bean的作用域，如果是使用XML配置的Bean，可以使用scope属性

web作用域

session和request比较特殊。

Session作用域的应用：购物车。如果按照默认情况，购物车是单例的话，就会导致所有人都往同一个购物车中添加商品。如果是原型，就会导致一个用户在一次浏览网页并添加商品到购物车的过程中，购物车中的商品无法合并。可以使用如下方式进行配置

@Scope(value = WebApplicationContext.SCOPE_SESSION, proxyMode = ScopedProxyMode.INTERFACES)

proxyMode = ScopedProxyMode.INTERFACES解决了将Session作用域的Bean注入到单例Bean中所遇到的问题。

对于单例的Bean，在程序启动的时候，就会被创建，而Session作用域的Bean，是在用户使用过程中被创建的。如果一个单例的Bean依赖了Session作用域的Bean该怎么办呢？我们希望对于一个单例的实例，它所依赖的那个Session作用域的Bean，正好是当前会话的那个Bean。Spring通过代理解决这个问题。一开始注入的只不过是一个代理类，真正运行的时候，代理会对其进行懒解析，并调用委托给会话作用域内真正的Bean。

注意：如果@Bean方法返回的是一个接口，那是没问题的，可如果是一个实例的话，需要这样配置

proxyMode = ScopedProxyMode.TARGET_CLASS

以此来表明要以生成目标类扩展的方式创建代理

运行时注入

Spring提供了两种在运行时2注入的方式

1、属性占位符

2、 SpEL表达式语言

注入外部的值

package org.zln.spring4.core.ioc.bean;



import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.context.annotation.*;

import org.springframework.core.env.Environment;



import java.io.UnsupportedEncodingException;



/**

 * Created by sherry on 16/11/22.

 */

//指明这是一个Spring配置类

@Configuration

//扫描路径

@ComponentScan(basePackages = {"org.zln.spring4.core"}, resourcePattern = "**/*Bean.class")

@PropertySource("classpath:/app.properties")

public class ApplicationContextConfig {



    @Autowired

    Environment environment;



    @Bean

    public String string() throws UnsupportedEncodingException {

        return new String(environment.getProperty("title","哇哈哈").getBytes("UTF-8"),"UTF-8");

    }



}

哇哈哈是当从app.properties 中取不到值时赋给的默认值

使用占位符

先配置一个

@Bean

public PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer(){

    return new PropertySourcesPlaceholderConfigurer();

}

然后



@Bean

public String string(@Value("${title}") String title) {



    return title;

}

通过@Value(“${title}”)获取app.properties中配置的数据

完整代码如下

package org.zln.spring4.core.ioc.bean;



import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.context.annotation.*;

import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;

import org.springframework.core.env.Environment;





/**

 * Created by sherry on 16/11/22.

 */

//指明这是一个Spring配置类

@Configuration

//扫描路径

@ComponentScan(basePackages = {"org.zln.spring4.core"}, resourcePattern = "**/*Bean.class")

@PropertySource("classpath:/app.properties")

public class ApplicationContextConfig {



    @Autowired

    Environment environment;



    @Bean

    public PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer() {

        return new PropertySourcesPlaceholderConfigurer();

    }



    @Bean

    public String string(@Value("${title}") String title) {



        return title;

    }



}

如果希望实现对外部属性文件的加密解密，可以自定义实现 PropertySourcesPlaceholderConfigurer

SpEL表达式

SpEL是Spring3引入的

特性

1、使用Bean的ID来引用Bean

2、调用方法和访问对象的属性

3、对值进行算术、关系和逻辑运算

4、正则表达式匹配

5、集合操作

形式：#{SpEl表达式}

使用举例

#{T(System).currentTimeMilles()} T(System)表示java.lang.System类

#{bean1.pro1} bean1的pro1属性

#{bean1[‘pro1’]} 同上

总之：如果想要引入外部文件，就使用占位符，其他时候看需求来决定是否需要使用SpEL表达式

IoC最佳实践

一个根配置（不管是XML还是Java都行）

在根配置中设置扫描

在跟配置中引入其他各个模块的配置

灵活使用 profile、运行时注入等高级内容

小结

IOC做的事情，万变不离其宗，就是为了更好的维护好对象之间的关系，由Spring统一管理各个对象

重点有这么几个：

1、怎么管理Bean

2、怎么按照要求设置Bean之间的关系

3、怎么初始化Bean

4、更加灵活的对Bean进行初始化

AOP

AOP概述

AOP是面向切面的编程方式，有其特定的适用场景。

所谓面向切面，就是抽象出一些关注点，将这些关注点中重复做的事情从业务代码中分离开来

如果说DI有助于应用对象之间的解耦，那么AOP则有助于实现横切关注点与他们所影响的对象之间的解耦。

AOP术语

Aspect – 切面

描述哪些类的哪些方法我们需要做什么的地方

如果是注解，那么切面就是个类，如果采用XML的配置，那么切面就是一段XML配置

Pointcut – 切点

Join point - 连接点

连接点是应用执行过程中能够切入切面的一个点

Advice – 通知

Before – 前置通知：目标方法被调用前执行

After – 后置通知，目标方法完成后被调用执行

After-returning – 返回通知，目标方法成功执行后调用

After-throwing – 异常通知，目标方法抛出异常后调用

Around – 环绕通知，目标方法调用前调用后执行自定义行为

Introduction – 引入

往现有类中添加新的方法或属性

Weaving – 织入

把切面应用到目标并创建新的代理对象的过程

Spring提供的AOP支持

1、基于代理的经典Spring AOP

2、纯POJO切面

3、 @AspectJ注解驱动的切面

4、注入式AspectJ切面（适用于Spring各个版本）

Spring AOP构建在动态代理基础之上，所以Spring对AOP的支持局限于方法拦截

如果需要方法之外的拦截点，如字段、构造器等，可以考虑使用AspectJ

设置连接点

Spring AOP支持部分AspectJ的切点指示器

AspectJ指示器	描述
arg()	限制连接点匹配参数为指定类型的执行方法
@args()	限制连接点匹配参数由指定注解标注的执行方法
execution()	匹配连接点的执行方法
this()	限制连接点匹配AOP代理的bean引用为指定类型的类
target	限制连接点匹配目标对象为指定的类
@target()	限制连接点匹配特定的执行对象，这些对象对应的类要具有指定类型的注解
within()	限制连接点匹配指定的类型
@within()	限制连接点匹配指定注解所标注的类型
@annotation	限制匹配带有指定注解的连接点

AOP简单示例

切点

package org.zln.spring4.core.aop;



/**

 * Created by sherry on 16/11/23.

 */

//切点

public interface Performance {

    void perform();

}

package org.zln.spring4.core.aop;



import org.springframework.stereotype.Component;



/**

 * Created by sherry on 16/11/23.

 */



@Component

public class PerformanceImpl implements Performance {

    @Override

    public void perform() {

        System.out.println("我是perfom方法");

    }

}

切点就是要被环切的对象，这里用一个简单的接口和它的一个实现类来代理

在实现类上添加了@Component注解，这是为了被扫描到

切面

package org.zln.spring4.core.aop;



import org.aspectj.lang.ProceedingJoinPoint;

import org.aspectj.lang.annotation.*;

import org.springframework.stereotype.Component;



/**

 * Created by sherry on 16/11/23.

 */



//定义一个切面

@Aspect

@Component

public class Audience {



    //定义切点

    @Pointcut("execution(* org.zln.spring4.core.aop.Performance.perform(..))")

    public void performance(){}



    @Before("performance()")

    public void silenceCellPhones(){

        System.out.println("调用方法前1");

    }



    @Before("performance()")

    public void takeSeats(){

        System.out.println("调用方法前2");

    }



    @After("performance()")

    public void applause(){

        System.out.println("调用方法后1");

    }



    @AfterReturning("performance()")

    public void app1(){

        System.out.println("调用方法后2");

    }



    @AfterThrowing("performance()")

    public void demandRefund(){

        System.out.println("抛出异常");

    }



    @Around("performance()")

    public void watchPerform(ProceedingJoinPoint proceedingJoinPoint){

        System.out.println("环绕通知1");

        try {

            proceedingJoinPoint.proceed();

            System.out.println("环绕通知2");

        } catch (Throwable throwable) {

            throwable.printStackTrace();

        }

    }



}

@Ascept表明当前类是一个切面

@Component是为了被扫描到

@Pointcut定义了一个切点

Java配置Spring

package org.zln.spring4.core.aop;



import org.springframework.context.annotation.ComponentScan;

import org.springframework.context.annotation.Configuration;

import org.springframework.context.annotation.EnableAspectJAutoProxy;



/**

 * Created by sherry on 16/11/23.

 */

@Configuration

@ComponentScan(basePackages = {"org.zln.spring4.core.aop"})

//启用AspectJ自动代理

@EnableAspectJAutoProxy

public class SpringConf {

}

测试

package org.zln.spring4.core.aop;



import org.springframework.context.ApplicationContext;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;



/**

 * Created by sherry on 16/11/23.

 */

public class AopMain {



    public static void main(String[] args) {

        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConf.class);

        Performance performance = applicationContext.getBean(Performance.class);

        performance.perform();

    }



}

运行结果

环绕通知1

调用方法前1

调用方法前2

我是perfom方法

环绕通知2

调用方法后1

调用方法后2

小结

AOP是一种面向切面的思想，如果在实际开发过程中，发现大量的属于面向切面的活儿，就可以考虑使用Spring AOP

如果Spring AOP无法满足要求，则考虑AspectJ等其他AOP框架

Spring MVC

（参考开涛、《Spring MVC学习指南》、《看透Spring MVC源代码分析与实践》）

框架简介

Spring MVC是Spring团队实现的一个MVC框架

由DispatcherServlet作为前端控制器分派请求，

各种注解配置大大简化了开发

同时返回视图解析器也是配置化的

DispatcherServlet

DispatcherServlet是前端控制器设计模式的实现，提供Spring Web MVC的集中访问点，而且负责职责的分派，而且与Spring IoC容器无缝集成，从而可以获得Spring的所有好处。

DispatcherServlet主要用作职责调度工作，本身主要用于控制流程，主要职责如下：

1、文件上传解析，如果请求类型是multipart将通过MultipartResolver进行文件上传解析；

2、通过HandlerMapping，将请求映射到处理器（返回一个HandlerExecutionChain，它包括一个处理器、多个HandlerInterceptor拦截器）；

3、通过HandlerAdapter支持多种类型的处理器(HandlerExecutionChain中的处理器)；

4、通过ViewResolver解析逻辑视图名到具体视图实现；

5、本地化解析；

6、渲染具体的视图等；

7、如果执行过程中遇到异常将交给HandlerExceptionResolver来解析。

框架搭建

在web项目中使用Spring和Spring MVC，需要创建两个Spring上下文

可以使用xml和java进行配置

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-instance"

         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"

         version="3.1">



    <!--① 启动Spring-->

    <context-param>

        <param-name>contextConfigLocation</param-name>

        <param-value>classpath:applicationContext*.xml</param-value>

    </context-param>



    <!--配置日志-->

    <context-param>

        <param-name>log4jConfigLocation</param-name>

        <param-value>WEB-INF/log4j2.xml</param-value>

    </context-param>

    <!--通过监听装载日志配置文件-->

    <listener>

        <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>

    </listener>



    <!--过滤器设置请求编码-->

    <filter>

        <filter-name>CharacterEncodingFilter</filter-name>

        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>

        <init-param>

            <param-name>encoding</param-name>

            <param-value>utf-8</param-value>

        </init-param>

    </filter>

    <filter-mapping>

        <filter-name>CharacterEncodingFilter</filter-name>

        <url-pattern>/*</url-pattern>

    </filter-mapping>



    <!--② 启动Spring容器的监听,引用①处的上下文参数获取Spring配置文件地址-->

    <listener>

        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

    </listener>



    <!--③ 配置Spring MVC地址映射-->

    <servlet>

        <servlet-name>spring4-mvc</servlet-name>

        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

        <init-param>

            <param-name>contextConfigLocation</param-name>

            <param-value>/WEB-INF/springServlet/*-servlet.xml</param-value>

        </init-param>

        <load-on-startup>2</load-on-startup>

    </servlet>

    <servlet-mapping>

        <servlet-name>spring4-mvc</servlet-name>

        <url-pattern>/</url-pattern>

    </servlet-mapping>



    <welcome-file-list>

        <welcome-file>index.jsp</welcome-file>

    </welcome-file-list>



</web-app>

/Users/sherry/WorkPath/Git/Spring/spring4/spring4-mvc-demo01/src/main/webapp/WEB-INF/springServlet/app-servlet.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:context="http://www.springframework.org/schema/context"

       xmlns:p="http://www.springframework.org/schema/p"

       xmlns:mvc="http://www.springframework.org/schema/mvc"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

       http://www.springframework.org/schema/beans/spring-beans-4.1.xsd

       http://www.springframework.org/schema/context

       http://www.springframework.org/schema/context/spring-context-4.1.xsd

       http://www.springframework.org/schema/mvc

       http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd">



    <!--各种组件注册-->

    <mvc:annotation-driven/>

    <!--只扫描 @Controller 的类-->

    <context:component-scan base-package="org.zln" use-default-filters="false">

        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>

    </context:component-scan>



    <!--静态资源-->

    <mvc:resources mapping="/css/**" location="/WEB-INF/css/"/>

    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"

          p:viewClass="org.springframework.web.servlet.view.JstlView"

          p:prefix="/WEB-INF/jsp/"

          p:suffix=".jsp"/>

</beans>

java

Servlet3.0开始，可以在java中配置两个Spring上下文，不再需要在web.xml中进行配置

主配置文件

package org.zln.spring4.mvc.conf;



import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;



/**

 * 配置DispatcherServlet

 * Created by sherry on 16/11/23.

 *

 * 继承了AbstractAnnotationConfigDispatcherServletInitializer的类都会自动地配置DispatcherServlet和Spring应用上下文

 * Spring应用上下文会位于程序的Servlet上下文之中

 * 其效果与配置在web.xml中一致

 *

 * 注意:这是在Servlet3和Spring3.1之后才有的功能

 *

 * 在Servlet3.0环境下,容器会在类路径查找

 *

 */

public class WebAppInit extends AbstractAnnotationConfigDispatcherServletInitializer {



    /**

     * 配置映射路径

     * @return

     */

    @Override

    protected String[] getServletMappings() {

        return new String[]{"/"};

    }



    /**

     * 配置Web组件相关的Bean  控制器视图解析器  处理器映射等

     * bean在DispatcherServlet上下文中

     * @return

     */

    @Override

    protected Class<?>[] getServletConfigClasses() {

        return new Class<?>[]{WebConfig.class};

    }



    /**

     * 驱动应用后端的中间层和数据层组件

     * bean在ContextLoaderListener上下文中

     * @return

     */

    @Override

    protected Class<?>[] getRootConfigClasses() {

        return new Class<?>[]{RootConfig.class};

    }



}

Spring MVC配置文件

package org.zln.spring4.mvc.conf;



import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.ComponentScan;

import org.springframework.context.annotation.Configuration;

import org.springframework.web.servlet.ViewResolver;

import org.springframework.web.servlet.config.annotation.DefaultServletHandlerConfigurer;

import org.springframework.web.servlet.config.annotation.EnableWebMvc;

import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

import org.springframework.web.servlet.view.InternalResourceViewResolver;



/**

 * web的Spring配置

 * Created by sherry on 16/11/23.

 */



@Configuration

@EnableWebMvc

@ComponentScan(basePackages = "org.zln.spring4.mvc",resourcePattern = "**/*Controller.class")

public class WebConfig extends WebMvcConfigurerAdapter{



    /**

     * 配置JSP视图解析器

     * @return

     */

    @Bean

    public ViewResolver viewResolver(){

        InternalResourceViewResolver resourceViewResolver = new InternalResourceViewResolver();

        resourceViewResolver.setPrefix("/WEB-INF/views");

        resourceViewResolver.setSuffix(".jsp");

        resourceViewResolver.setExposeContextBeansAsAttributes(true);

        return resourceViewResolver;

    }



    /**

     * 配置静态资源的处理:要求DispatcherServlet将对静态资源的请求转发到Servlet容器默认的Servlet上,而不是使用DispatcherServlet本身来处理

     * @param configurer

     */

    @Override

    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {

        configurer.enable();

    }

}

Spring 后端Bean配置文件

package org.zln.spring4.mvc.conf;



import org.springframework.context.annotation.ComponentScan;

import org.springframework.context.annotation.Configuration;

import org.springframework.context.annotation.FilterType;

import org.springframework.web.servlet.config.annotation.EnableWebMvc;



/**

 * 配置处理web bean外的所有需要纳入Spring管理的Bean

 * Created by sherry on 16/11/23.

 */

@Configuration

@ComponentScan(basePackages = {"org.zln.spring4"}, excludeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION, value = EnableWebMvc.class)})

public class RootConfig {

}

一个简单的控制器

package org.zln.spring4.mvc.controller;



import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.stereotype.Controller;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestMethod;



/**

 * Created by sherry on 16/11/23.

 */

@Controller

public class HomeController {



    /**

     * 日志

     */

    private Logger logger = LoggerFactory.getLogger(HomeController.class);



    @RequestMapping(value = {"/home","/"}, method = RequestMethod.GET)

    public String home() {

        logger.debug("进入home");

        return "/home";

    }



}

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-instance"

         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"

         version="3.1">





    <!--过滤器设置请求编码-->

    <filter>

        <filter-name>CharacterEncodingFilter</filter-name>

        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>

        <init-param>

            <param-name>encoding</param-name>

            <param-value>utf-8</param-value>

        </init-param>

    </filter>

    <filter-mapping>

        <filter-name>CharacterEncodingFilter</filter-name>

        <url-pattern>/*</url-pattern>

    </filter-mapping>





</web-app>

小结

我觉得比较好的方式是，主要使用Java进行配置，Java配置作为入口，配置好两个Spring上下文的Java类，在这两个类中再去引入必要的xml配置文件。再由XML去引入其它各个子模块的配置

请求映射

@RequestMapping

@RequestMapping可以注解在类上或方法上，也可以同时标注。两个共同决定了类能够处理的请求

举例如下



@Controller

@RequestMapping("/")

public class HomeController {

    @RequestMapping(value = "home/list")

    public String home() {

        return "/home";

    }



}

home方法能够处理 /home/list的请求

value属性

value属性是一个数组，@RequestMapping(value = {“/home1”,”/home2”}) 说明方法能够处理多种URL的请求

@RequestMapping(value="/users/**")：可以匹配“/users/abc/abc”，但“/users/123”将会被【URI模板模式映射中的“/users/{userId}”模式优先映射到】

@RequestMapping(value="/product?")：可匹配“/product1”或“/producta”，但不匹配“/product”或“/productaa”;

@RequestMapping(value="/product*")：可匹配“/productabc”或“/product”，但不匹配“/productabc/abc”;

@RequestMapping(value="/product/*")：可匹配“/product/abc”，但不匹配“/productabc”;

@RequestMapping(value="/products/**/{productId}")：可匹配“/products/abc/abc/123”或“/products/123”，也就是Ant风格和URI模板变量风格可混用

@RequestMapping(value="/products/{categoryCode:\d+}-{pageNumber:\d+}")：可以匹配“/products/123-1”，但不能匹配“/products/abc-1”，这样可以设计更加严格的规则

method属性

method属性是一个数组，@RequestMapping(value = “/home”.method = {RequestMethod.POST，RequestMethod.GET})

params属性

@RequestMapping(params="create", method=RequestMethod.GET) ：表示请求中有“create”的参数名且请求方法为“GET”即可匹配，如可匹配的请求URL“http://×××/parameter1?create”；

@RequestMapping(params="create", method=RequestMethod.POST)：表示请求中有“create”的参数名且请求方法为“POST”即可匹配；

@RequestMapping(params="!create", method=RequestMethod.GET)：表示请求中没有“create”参数名且请求方法为“GET”即可匹配，如可匹配的请求URL“http://×××/parameter1?abc”。

@RequestMapping(params="submitFlag=create", method=RequestMethod.GET)：表示请求中有“submitFlag=create”请求参数且请求方法为“GET”即可匹配，如请求URL为http://×××/parameter2?submitFlag=create；

@RequestMapping(params="submitFlag!=create", method=RequestMethod.GET)：表示请求中的参数“submitFlag!=create”且请求方法为“GET”即可匹配，如可匹配的请求URL“http://×××/parameter1?submitFlag=abc”。

@RequestMapping(params={"test1", "test2=create"})：表示请求中的有“test1”参数名且有“test2=create”参数即可匹配，如可匹配的请求URL“http://×××/parameter3?test1&test2=create。

headers属性

@RequestMapping(value="/header/test1", headers = "Accept")：表示请求的URL必须为“/header/test1”

且请求头中必须有Accept参数才能匹配。

@RequestMapping(value="/header/test1", headers = "abc")：表示请求的URL必须为“/header/test1”

且请求头中必须有abc参数才能匹配，如图6-8时可匹配。

@RequestMapping(value="/header/test2", headers = "!abc")：表示请求的URL必须为“/header/test2”

且请求头中必须没有abc参数才能匹配。（将Modify Header的abc参数值删除即可）。

@RequestMapping(value="/header/test3", headers = "Content-Type=application/json")：表示请求的URL必须为“/header/test3” 且请求头中必须有“Content-Type=application/json”参数即可匹配。

当你请求的URL为“/header/test3” 但如果请求头中没有或不是“Content-Type=application/json”参数（如“text/html”其他参数），将返回“HTTP Status 415”状态码【表示不支持的媒体类型(Media Type)，也就是MIME类型】，即我们的功能处理方法只能处理application/json的媒体类型。

@RequestMapping(value="/header/test4", headers = "Accept=application/json")：表示请求的URL必须为“/header/test4” 且请求头中必须有“Accept =application/json”参数即可匹配。（将Modify Header的Accept参数值改为“application/json”即可）；

@RequestMapping(value="/header/test5", headers = "Accept=text/*") ：表示请求的URL必须为“/header/test5” 且请求头中必须有如“Accept=text/plain”参数即可匹配。（将Modify Header的Accept参数值改为“text/plain”即可）；

@RequestMapping(value="/header/test6", headers = "Accept=*/*") ：表示请求的URL必须为“/header/test6” 且请求头中必须有任意Accept参数即可匹配。Accept=*/*：表示主类型任意，子类型任意，如“text/plain”、“application/xml”等都可以匹配。

@RequestMapping(value="/header/test7", headers = "Accept!=text/vnd.wap.wml")：表示请求的URL必须为“/header/test7” 且请求头中必须有“Accept”参数但值不等于“text/vnd.wap.wml”即可匹配。

@RequestMapping(value="/header/test8", headers = {"Accept!=text/vnd.wap.wml","abc=123"})：表示请求的URL必须为“/header/test8” 且请求头中必须有“Accept”参数但值不等于“text/vnd.wap.wml”且请求中必须有参数“abc=123”即可匹配。

注：Accept:text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8

如果您的请求中含有Accept：“*/*”，则可以匹配功能处理方法上的如“text/html”、“text/*”，“application/xml”等。

①服务器端可以通过指定【headers = "Content-Type=application/json"】来声明可处理（可消费）的媒体类型，即只消费Content-Type指定的请求内容体数据；

②客户端如何告诉服务器端它只消费什么媒体类型的数据呢？即客户端接受（需要）什么类型的数据呢？服务器应该生产什么类型的数据？此时我们可以请求的Accept请求头来实现这个功能。

获取请求参数

@RequestParam

注解在控制器方法的参数上，如： @RequestParam String id，就会把请求参数中名为id的数据注入给id参数。如果请求参数和方法参数名称不一致，则可以手动指定。@RequestParam(“id”) String name

required属性

请求中是否必须有这个参数。默认是true。如果没有是会报错的

defaultValue属性

为请求参数设置默认值，如果没有这个请求参数，就将默认值注入到控制器的方法参数上

@ModelAttribute

请求参数到命令对象的绑定；

@CookieValue

cookie数据到处理器功能处理方法的方法参数上的绑定；

@RequestHeader

请求头（header）数据到处理器功能处理方法的方法参数上的绑定；

@RequestBody

请求的body体的绑定（通过HttpMessageConverter进行类型转换）；

@PathVariable

请求URI中的模板变量部分到处理器功能处理方法的方法参数上的绑定，从而支持RESTful架构风格的URI；

@RequestPart

绑定“multipart/data”数据，除了能绑定@RequestParam能做到的请求参数外，还能绑定上传的文件等。

POJO

对于一个普通的，带有setter方法的类，作为控制器方法的参数，会将请求中的请求参数按照名称注入到POJO的成员变量上

表单校验

表单校验只做和业务逻辑无关的输入校验，一般如非空、长度、合法性等，如果正常，就将请求参数赋值给命令对象或者其他对象，在处理方法中继续处理，否则就直接返回给请求页面，在请求页面中显示错误提示。

有两种方式做表单的后端校验

1、自己编写验证器。在Controller方法中进行调用（见Spring MVC学习指南 p106--108）

2、JSR 303 Hibernate中有实现。

过滤器

以下代码是继承OncePerRequestFilter实现登录过滤的代码：

1 package com.test.spring.filter;

3 import java.io.IOException;

4 import java.io.PrintWriter;

6 import javax.servlet.FilterChain;

7 import javax.servlet.ServletException;

8 import javax.servlet.http.HttpServletRequest;

9 import javax.servlet.http.HttpServletResponse;

11 import org.springframework.web.filter.OncePerRequestFilter;

13 /**

14 * 登录过滤

15 *

16 * @author geloin

17 * @date 2012-4-10 下午2:37:38

18 */

19 public class SessionFilter extends OncePerRequestFilter {

21 /*

22 * (non-Javadoc)

23 *

24 * @see

25 * org.springframework.web.filter.OncePerRequestFilter#doFilterInternal(

26 * javax.servlet.http.HttpServletRequest,

27 * javax.servlet.http.HttpServletResponse, javax.servlet.FilterChain)

28 */

29 @Override

30 protected void doFilterInternal(HttpServletRequest request,

31 HttpServletResponse response, FilterChain filterChain)

32 throws ServletException, IOException {

34 // 不过滤的uri

35 String[] notFilter = new String[] { "login.html", "index.html" };

37 // 请求的uri

38 String uri = request.getRequestURI();

40 // uri中包含background时才进行过滤

41 if (uri.indexOf("background") != -1) {

42 // 是否过滤

43 boolean doFilter = true;

44 for (String s : notFilter) {

45 if (uri.indexOf(s) != -1) {

46 // 如果uri中包含不过滤的uri，则不进行过滤

47 doFilter = false;

48 break;

49 }

50 }

51 if (doFilter) {

52 // 执行过滤

53 // 从session中获取登录者实体

54 Object obj = request.getSession().getAttribute("loginedUser");

55 if (null == obj) {

56 // 如果session中不存在登录者实体，则弹出框提示重新登录

57 // 设置request和response的字符集，防止乱码

58 request.setCharacterEncoding("UTF-8");

59 response.setCharacterEncoding("UTF-8");

60 PrintWriter out = response.getWriter();

61 String loginPage = "....";

62 StringBuilder builder = new StringBuilder();

63 builder.append("<script type="text/javascript">");

64 builder.append("alert(‘网页过期，请重新登录！‘);");

65 builder.append("window.top.location.href=‘");

66 builder.append(loginPage);

67 builder.append("‘;");

68 builder.append("</script>");

69 out.print(builder.toString());

70 } else {

71 // 如果session中存在登录者实体，则继续

72 filterChain.doFilter(request, response);

73 }

74 } else {

75 // 如果不执行过滤，则继续

76 filterChain.doFilter(request, response);

77 }

78 } else {

79 // 如果uri中不包含background，则继续

80 filterChain.doFilter(request, response);

81 }

82 }

84 }

写完过滤器后，需要在web.xml中进行配置：

<filter-name>sessionFilter</filter-name>

<filter-class>com.test.spring.filter.SessionFilter</filter-class>

</filter>

<filter-mapping>

<filter-name>sessionFilter</filter-name>

<url-pattern>/*</url-pattern>

</filter-mapping>

文件上传

Spring MVC学习指南 p174---179

思路：命令对象中有一个List<MultipartFile>类型的对象来接收前端发起的文件上传请求

在配置文件中，可以通过对CommonMultipartResolver的属性的配置，配置文件上传的最大值。默认是没有容量限制的。在上传超大文件的时候，一般要使用 HTML5 的File API将文件切割，再分别上传。

在Servlet 3之前，文件上传需要借助组件，一般是 common-fileupload，在Servlet 3以后，就不需要了。见《Spring MVC学习指南》 page 185

响应请求

@ResponseBody

处理器功能处理方法的返回值作为响应体（通过HttpMessageConverter进行类型转换）；

@ResponseStatus

定义处理器功能处理方法/异常处理器返回的状态码和原因；

redirect

return “redirect:/web/home.jsp”

表示重定向到指定页面，相当于在浏览器输入地址

Flash属性

在控制器方法参数中添加 RedirectAtrributes类型的参数，调用其addFlashAtteribute()方法，就可以把当前的数据传递给重定向后的页面。如果只是将数据存储在request的话，重定向后就消失了

字符串

跳转到字符串指定的页面上

响应视图

测试

使用MockMvc对Controller进行简单的测试

package org.zln.spring4.mvc.controller;



import org.junit.Test;

import org.springframework.test.web.servlet.MockMvc;

import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;

import org.springframework.test.web.servlet.result.MockMvcResultMatchers;

import org.springframework.test.web.servlet.setup.MockMvcBuilders;



/**

 * Created by sherry on 16/11/24.

 */

public class HomeControllerTest {



    @Test

    public void testHome() throws Exception {

        HomeController homeController = new HomeController();

        MockMvc mockMvc = MockMvcBuilders.standaloneSetup(homeController).build();

        mockMvc.perform(MockMvcRequestBuilders.get("/")).andExpect(MockMvcResultMatchers.view().name("/home"));

    }

}

Spring 提供了强大的MockMvc功能用于对Spring MVC的控制器进行测试。基本上可以模拟网页请求。

Spring视图

Apache Tiles

Thymeleaf

类型转换器

因为HTTP的特性，请求数据过来的时候，都是字符串，这个时候如果命令对象的某个属性是其他类型的，如日期类型，就需要进行类型转换。Spring MVC默认已经提供了很多类型转换器，我们也可以自己实现。

步骤如下：

1、实现Converter<S,T>接口，S表示源类型，T表示目标类型

2、注册自定义的类型转换器

<list>

</list>

</property>

</bean>

<mvc:annotation-drvien conversion-service=”cs”/>

另一种方式是实现Formatter，Formatter更适用于Web层，其源类型必须是String。注册过程如下

<set>

</set>

</property>

</bean>

REST支持

什么是REST？

Spring MVC对REST的支持

数据库支持

数据源配置

Drud数据源

<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close"

      p:driverClassName="com.mysql.jdbc.Driver"

      p:url="jdbc:mysql://localhost:3306/zln?useSSL=false"

      p:username="root"

      p:password="123456"/>

JNDI数据源

如果应用程序部署在web容器中，则数据源一般采用JNDI的方式

<jee:jndi-lookup jndi-name="/jdbc/bdrisk" id="dataSource"

                 resource-ref="true"/>

resource-ref=”true”，则jndi-name会自动添加 java:comp/env 前缀

如果用java配置

@Bean

public JndiObjectFactoryBean dataSource(){

    JndiObjectFactoryBean jndiObjectFactoryBean = new JndiObjectFactoryBean();

    jndiObjectFactoryBean.setJndiName("jdbc/bdrisk");

    jndiObjectFactoryBean.setResourceRef(true);

    jndiObjectFactoryBean.setProxyInterface(javax.sql.DataSource.class);

    return jndiObjectFactoryBean;

}

Spring自身也提供了线程连接功能，但性能不佳，故不推荐

整合JdbcTemplate

配置数据源后

<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"

      p:dataSource-ref="dataSource"/>

就可以将JDBCTemplate注入给Dao访问数据库了

或者使用NamedJdbcTemplate

<bean id="namedJdbcTemplate" class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate"

      c:dataSource-ref="dataSource"/>

NamedJdbcTemplate是一种特殊的JDBC模板，支持命名参数功能

整合MyBatis

（这些的集成方式，等学具体的持久层的时候再学）

整合Hibernate

整合JPA

Spring Date

使用NoSQL数据库

MongoDB

Neo4j

Redis

缓存

远程服务

远程调用类似于调用一个本地对象的方法，是同步操作，会阻塞调用代码的执行，知道被调用的过程执行完毕。

RMI

适用场景：不考虑网络限制（如防火墙），访问/发布基于Java的服务

RMI很难穿透防火墙，因为RMI使用任意端口进行交互，这通常是防火墙所不允许的。

RMI是基于Java的，意味着客户端和服务端都要使用Java开发

RMI使用Java的序列化机制，所以通过网络传输的对象类型必须保证在调用两端的Java运行时中是完全相同的版本

服务端

<?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:context="http://www.springframework.org/schema/context"

       xmlns:tx="http://www.springframework.org/schema/tx"

       xmlns:p="http://www.springframework.org/schema/p"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

       http://www.springframework.org/schema/beans/spring-beans-3.2.xsd

       http://www.springframework.org/schema/context

       http://www.springframework.org/schema/context/spring-context-3.2.xsd

       http://www.springframework.org/schema/tx

       http://www.springframework.org/schema/tx/spring-tx-3.2.xsd">



    <bean id="hello" class="org.zln.bdrisk.col.HelloImpl"/>



    <bean class="org.springframework.remoting.rmi.RmiServiceExporter">

        <!-- RMI服务名称,可自定义服务名称 -->

        <property name="serviceName" value="helloService" />

        <!-- 导出实体 -->

        <property name="service" ref="hello" />

        <!-- 导出接口 -->

        <property name="serviceInterface" value="org.zln.bdrisk.col.IHello" />

        <!-- spring默认使用1099端口 -->

        <property name="registryPort" value="8888" />

    </bean>





</beans>

客户端

<?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:context="http://www.springframework.org/schema/context"

       xmlns:tx="http://www.springframework.org/schema/tx"

       xmlns:p="http://www.springframework.org/schema/p"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

       http://www.springframework.org/schema/beans/spring-beans-3.2.xsd

       http://www.springframework.org/schema/context

       http://www.springframework.org/schema/context/spring-context-3.2.xsd

       http://www.springframework.org/schema/tx

       http://www.springframework.org/schema/tx/spring-tx-3.2.xsd">



    <bean id="hello" class="org.springframework.remoting.rmi.RmiProxyFactoryBean">

        <property name="serviceUrl" value="rmi://localhost:8888/helloService" />

        <property name="serviceInterface" value="org.zln.bdrisk.col.IHello" />

    </bean>

</beans>

服务端只要Spring实例化了，RMI服务对象就会注册好等着被调用，客户端上填写好服务端的地址和服务名，然后从Spring容器中获取远程对象即可

RMI与Spring集成后，编写RMI服务类和普通的接口、实现没有区别，不再需要集成、抛出指定异常等。

Hessian和Burlap

谷歌一下

适用场景：考虑网络限制时，通过HTTP访问/发布基于Java的服务。Hessian是基于二进制协议，Burlap基于XML

Spring的HttpInvoker

谷歌一下

适用场景：考虑网络限制，并希望使用基于XML或专有的序列化机制实现Java序列化，访问/发布基于Spring的服务

JAX-RPC和JAX-WS

谷歌一下

适用场景：访问/发布平台独立的，基于SOAP的Web服务

异步消息

消息代理和目的地

当应用发送消息的时候，会将消息交给消息代理，由消息代理确保将消息投递到指定的目的地。同时解放发送者，可以进行其他业务

点对点消息模型：

每条消息都有一个发送者和接受者

发布—订阅模型：

消息发送给一个主题，多个接收者可以订阅监听这一主题。所有订阅了这个主题的接收者都能收到消息的副本

JMS

Java Message Service

ActiveMQ是一款比较好的JMS异步消息传递产品

ActiveMQ充当的就是消息代理的角色

示例

先从官网下载二进制发行包：http://activemq.apache.org

启动ActiveMQ服务

配置

<?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:context="http://www.springframework.org/schema/context"

       xmlns:tx="http://www.springframework.org/schema/tx"

       xmlns:jms="http://www.springframework.org/schema/jms"

       xmlns:amq="http://activemq.apache.org/schema/core"

       xmlns:p="http://www.springframework.org/schema/p"

       xmlns:c="http://www.springframework.org/schema/c"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

       http://www.springframework.org/schema/beans/spring-beans-4.3.xsd

       http://www.springframework.org/schema/context

       http://www.springframework.org/schema/context/spring-context-4.3.xsd

       http://activemq.apache.org/schema/core

       http://activemq.apache.org/schema/core/activemq-core.xsd

       http://www.springframework.org/schema/tx

       http://www.springframework.org/schema/tx/spring-tx-4.3.xsd

       http://www.springframework.org/schema/jms

       http://www.springframework.org/schema/jms/spring-jms-4.1.xsd">



    <!--这个包下的,所有加过特殊注解的类,都被Spring管理-->

    <context:component-scan base-package="org.zln" resource-pattern="**/*Dao.class"/>

    <context:component-scan base-package="org.zln" resource-pattern="**/*Service.class"/>



    <!--开启注解注入-->

    <context:annotation-config/>



    <!--

    配置连接工厂,默认监听tcp://localhost:61616.可以根据实际情况进行修改

    -->

    <!--<bean id="connectionFactory" class="org.apache.activemq.spring.ActiveMQConnectionFactory"-->

          <!--p:brokerURL="tcp://localhost:61616"/>-->

    <!--上下两段配置等效,下面的配置更简洁-->

    <!--如果我们使用不同的消息代理实现,他们不一定提供Spring配置命名空间,那么就需要使用bean来装配连接工厂-->

    <amq:connectionFactory id="connectionFactory" brokerURL="tcp://localhost:61616"/>





    <!--配置ActiveMQ消息的目的地

    目的地可以是一个队列,也可以是一个主题

    -->

    <!--队列-->

    <!--<bean id="queue" class="org.apache.activemq.command.ActiveMQQueue"-->

          <!--c:name="spitter.queue"/>-->

    <!--主题-->

    <!--<bean id="topic" class="org.apache.activemq.command.ActiveMQTopic"-->

          <!--c:name="spitter.topic"/>-->

    <!--使用amp命名空间简化配置-->

    <!--physicalName指定队列名称-->

    <amq:queue id="queue" physicalName="spitter.queue"/>

    <!--physicalName指定消息通道名称-->

    <amq:topic id="topic" physicalName="spitter.topic"/>





    <!--Spring对JMS的支持  defaultDestination 指定默认发送目的地-->

    <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate"

          c:connectionFactory-ref="connectionFactory"

          p:defaultDestination-ref="queue"/>



</beans>

发送端代码

package org.zln.spring4.mq;



import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.jms.core.JmsOperations;

import org.springframework.jms.core.MessageCreator;



import javax.jms.JMSException;

import javax.jms.Message;

import javax.jms.Session;



/**

 * Created by sherry on 16/11/27.

 */

public class AlertServiceImpl implements AlertService {



//    JmsOperations是JmsTemplate所实现的接口

    @Autowired

    private JmsOperations jmsOperations;



    @Override

    public void sendJmsMsg(String msg) {

        jmsOperations.send("spitter.queue",//指定消息发送的目的地,如果不传,就发送给JmsTemplate配置的默认目的地

                new MessageCreator() {//构造要发送的消息

                    @Override

                    public Message createMessage(Session session) throws JMSException {

                        return session.createObjectMessage(msg);

                    }

                });

        jmsOperations.convertAndSend(msg);//使用convertAndSend发送消息,就会自动将要发送的数据转化为消息对象进行发送

        /*

        Spring已经提供了多种转化器,默认使用SimpleMessageConverter

        如果想要使用其他的转化器,则将转化器声明为bean,然后配置给JmsTemplate即可

         */

    }

}

接收

如果直接接收，那么是同步的，我们一般会配置一个监听器，

<bean id="alertHandler" class="org.zln.spring4.mq.AlertHandler"/>

<jms:listener-container>

    <jms:listener destination="queue" ref="alertHandler" method="handlerAlert"/>

</jms:listener-container>

package org.zln.spring4.mq;



/**

 * Created by sherry on 16/11/27.

 */

public class AlertHandler {



    public void handlerAlert(String msg){//处理接收到的消息

        System.out.println("收到JMS消息:"+msg);

    }



}

AMQP

AMQP是高级消息队列协议，能够跨不同AMQP实现、跨语言和平台

RabbitMQ是一个流行的开源消息代理，它实现了AMQP。Spring AMQP为RabbitMQ提供了支持，包括RabbitMQ连接工厂、模板以及Spring配置命名空间

具体使用上和ActiveMQ很像，就不重复了，有需要在Google一下

WebSocket和STOMP

JMS和AMQP是在应用程序之间发送消息，但是如果应用是运行在Web浏览器中，就需要使用WebSocket技术了

Spring 4.0为WebSocket提供了技术支持，包括：

1、发送和接收消息的低级API

2、发送和接收消息的高级API

3、发送消息模板

4、支持SocketJs，用来解决浏览器端、服务器以及代理不支持WebSocket的问题

STOMP是基于WebSocket的一项技术，为浏览器-服务器之间的通信增加恰当的消息语义

Email

使用JavaMailSenderImpl来实现发送Email

个人小结：对于一个公司而言，像系统间的同步、异步消息收发，邮件的收发，都是属于基础服务，都会封装成专门的调用接口的，客户端和服务端只要把相关的信息往服务器上发送或监听就行了，由服务器统一处理。

自己有空可以尝试写一个邮件服务器，专门处理邮件的订阅与发送；一个异步消息服务器，内部可以采用MQ或AMQP

JMX

Spring对DI的支持，是通过应用中配置bean属性，但一旦应用部署运行，单独使用DI就不能改变这些配置了

如果我们希望深入了解正在运行的应用，并要在运行时改变配置，就可以使用Java管理扩展（Java Manage-ment Extensions JMS）

成果：

要求：

1、Spring MVC

通过JSON实现浏览器与Controller之间的交互

2、消息

MQ、AMQP，编写一个服务端，同时支持以上两种的请求调用

3、远程调用

RMI、Hessian和Burlap、HttpInvokey、JAX-RPC和JAX-WS实现远程调用

4、Email

邮箱发送与接收模块（可以配合异步消息来使用，但是前提是需要首先Email模块自己要独立出来）

5、JMX

尝试使用JMX动态管理Spring中的Bean，在程序运行的时候动态添加、删除、修改Bean的配置，并且查看Spring容器中Bean的情况

自定义需求：

参考当前我的工作项目，编写一个预警的查询系统

project： warningQry

warningQry-web

warningQry-web-service

warningQry-web-dao

warningQry-domain

warningQry-commons

warningQry-commons-mq

warningQry-commons-amqp

warningQry-server

说明：

项目分为前端和后端

前端：与客户直接交互，接收请求，进行查询，先查询本地，本地查询不到，调用（远程调用、异步消息）后端

后端：接收前端的查询请求，返回查询结果（远程调用、异步消息、邮件）

ok，需求就先这样子，就看自己啥时候能够完成了。

正文

spring4bak

IOC

IoC概述

简单案例

案例一：XML配置Bean

案例二：p命名空间注入

案例三：XML配置 通过构造函数注入

案例四：Java配置

案例五：使用class对象从Spring容器中获取对象

初始化Spring容器

AnnotationConfigApplicationContext/ AnnocactionConfigWebApplicationContext

ClassPathXmlApplicationContext

FileSystemXmlApplicationContext

XmlWebApplicationContext

Bean的生命周期

配置Spring的几种方案

XML中配置扫描

Java中配置扫描

Java中引用XML

XML中引用Java配置

Spring测试

环境与profile

Java中配置环境

XML中配置环境

激活profile

条件化Bean

首选Bean

Bean的作用域

web作用域

运行时注入

注入外部的值

SpEL表达式

使用举例

IoC最佳实践

小结

AOP

AOP概述

AOP术语

Aspect – 切面

Pointcut – 切点

Join point - 连接点

Advice – 通知

Introduction – 引入

Weaving – 织入

Spring提供的AOP支持

设置连接点

AOP简单示例

切点

切面

Java配置Spring

测试

小结

Spring MVC

框架简介

DispatcherServlet

框架搭建

xml

java

小结

请求映射

@RequestMapping

value属性

method属性

params属性

headers属性

获取请求参数

@RequestParam

required属性

defaultValue属性

@ModelAttribute

@CookieValue

@RequestHeader

@RequestBody

@PathVariable

@RequestPart

POJO

表单校验

过滤器

文件上传

案例三：XML配置通过构造函数注入