Spring

简介

Spring 是一个支持快速开发 Java EE 应用程序的框架，它提供了一系列底层容器和基础设施，并可以和大量常用的开源框架无缝集成，可以说是开发 Java EE 应用程序的必备；
Spring 最早是由 Rod Johnson 在他的《Expert One-on-One J2EE Development without EJB》一书中提出的用来取代 EJB（企业级 JavaBean ---- Enterprise JavaBean，是一个用来构筑企业级应用的服务器端）的轻量级框架，随后这哥们又开始专心开发这个基础框架，并起名为 Spring Framework，随着 Spring 越来越受欢迎，在 Spring Framework 基础上，又诞生了 Spring Boot、Spring Cloud、Spring Data、Spring Security 等一系列基于 Spring Framework 的项目；
Spring Framework 组成

支持 IOC、AOP 的容器；
支持 JDBC、ORM 的数据访问模块；
支持声明式事务的模块；
支持基于 Servlet 的 MVC 开发；
支持基于 Reactive 的 Web 开发；
以及集成 JMS、JavaMail、JMX、缓存等其他模块；

Spring 结构图

Core

spring-core：控制反转 IOC 与依赖注入 DI 的最基本实现；
spring-beans：Bean 工厂与 Bean 的装配 ---- 依赖 core；
spring-expression：Spring 表达式语言 ---- 依赖 core；
spring-context：Spring 的 Context 上下文即 IOC 容器 ---- 依赖 core、beans、expression；
spring-context-support：Spring 额外支持包，比如邮件服务、视图解析等 ---- 依赖 core、beans、context；

spring-aop：面向切面编程 ---- 依赖 core、beans、aopalliance；
spring-aspects：集成 AspectJ ---- 依赖 aspectjweaver；
spring-instrument：提供一些类级的工具支持和 ClassLoader 级的实现，用于服务器；
spring-instrument-tomcat：针对 Tomcat 的 Instrument 实现；
spring-messaging：用于构建基于消息的应用程序 ---- 依赖 core、beans、context；

Data Access

spring-tx：事务控制 ---- 依赖 core、beans；
spring-jdbc：Jdbc 的支持 ---- 依赖 core、beans、tx；
spring-orm：对象关系映射，集成 ORM 框架 ---- 依赖 core、beans、jdbc、tx；
spring-oxm：对象 xml 映射 ---- 依赖 core、beans；
spring-jms：Java 消息服务 ---- 依赖 core、beans、aop、tx、context；

spring-web：基础 Web 功能，如文件上传 ---- 依赖 core、beans、aop、context；
spring-websocket：为 Web 应用提供的高效通信工具 ---- 依赖 core、web、context；
spring-webmvc：MVC 实现 ---- 依赖 core、beans、web、expression、context；
spring-webmvc-portlet：基于 Portlet 的 MVC 实现 ---- 依赖 core、beans、web、webmvc、context；
spring-struts：与 Struts 的集成，不推荐，Spring4 不再提供；

Test

spring-test：Spring 测试，提供 JUnit 与 Mock 测试功能 ---- 依赖 core；

IOC 容器

简介

Tomcat 是一个 Servlet 容器，它可以为 Servlet 的运行提供运行环境，除此之外，它底层还实现了 TCP 连接，解析 HTTP 协议等非常复杂的服务，如果没有容器来提供这些服务，我们就无法编写像 Servlet 这样代码简单、功能强大的组件；
Docker 也是一个容器，它提供了必要的 Linux 环境以便运行一个特定的 Linux 进程；
容器是一种为某种特定组件的运行提供必要支持的一个软件环境；
Spring Framework 的核心提供了一个 IOC 容器，它可以管理所有轻量级的 JavaBean 组件，提供的底层服务包括：组件的生命周期管理、配置和组装服务、AOP 支持、建立在 AOP 基础上的声明式事务服务等；

原理

在了解 IOC 之前，我们先来看看 Servlet 增删改查的案例；

ConfigUtil ---- DBUtil ---- UserDao ---- UserService ---- UserController；
分析下上面代码的依赖链；

ConfigUtil：静态方法获取配置内容；
DBUtil：通过反射实例化数据库连接；
UserDao：每个方法获取数据库连接，进行数据库操作；
UserService：通过 new 的方式产生 UserDao 对象；
UserController：通过 new 的方式产生 UserService 对象；

以上每个组件采用了 new 或“反射” 的方式创建实例，是否有什么不足？

实例化一个组件其实并不容易，要实例化 UserController，需要实例化 UserService、UserDao、DBUtil，ConfigUtil；
没有必要让每个控制器都实例化 UserService 对象，完全可以共享一个，但是谁负责创建？谁负责获取其他组件已经创建好的 UserService？这些并不好处理；
DBUtil 需要销毁和释放资源，但如果该组件被多个组件共享，如何确保它的使用方都已全部销毁？
随着更多组件的引入，比如添加其他模块的 Servlet，也需要用到 user 表数据，这些组件的依赖关系会越来越复杂；
----------------------------------------------
从上面的例子可以看出，如果一个系统有大量的组件，其生命周期和相互之间的依赖关系如果由组件自身来维护，不但大大增加了系统的复杂度，而且会导致组件之间极为紧密的耦合，继而给测试和维护带来了极大的困难；

核心问题

谁负责创建组件？
谁负责根据依赖关系组装组件？
销毁时，如何按依赖顺序正确销毁？

解决这些问题的核心方案就是 IOC；

IOC && DI

Inversion of Control，控制反转、Dependency Injection，依赖注入；
在传统的应用程序中，控制权在组件本身，由调用方按照依赖链实例化其他组件，在 IOC 模式下，控制权发生了反转，即从组件自身转移到了 IOC 容器，所有组件不再由应用程序自己创建和配置，而是由 IOC 容器负责，通过“依赖注入”的方式装配好组件，应用程序直接使用即可；
通俗点讲，通过两个问题来阐述 IOC 容器：谁控制了谁？ IOC 容器控制了 Bean 的创建和生命周期；怎么反转的？产生对象由 new 的方式变成了“依赖注入”的方式；

 
public class UserController extends HttpServlet {
    private UserService userService;
    …………
}

这一改动虽然简单，带来了一系列的好处；

UserController 不再关心如何创建 UserService；
UserService 可以被多个 Servlet 共享；
测试变得容易，不必使用真实环境；

IOC 容器要负责实例化所有的组件，因此，我们需要告诉容器如何创建组件、以及各组件之间的依赖关系，我们可以通过 XML 配置的方式来实现；

 
<bean id="userService" class="UserService">
    …………
</bean>
<bean id="userController" class="UserController">
    <property name="userService" ref="userService"/>
    …………
</bean>

2
Spring 的 IOC 容器中，我们把所有组件统称为 JavaBean，该配置指示 IOC 容器创建两个 JavaBean，并且将 userService 注入到 userController 中；

依赖注入的方式；

属性注入，通过 set 方法；
构造注入，通过构造器方法；
接口注入；
---------------------
Spring 的 IOC 容器同时支持属性注入和构造注入，并允许混合使用；

配置装配 Bean

案例：实现一个用户注册后，向用户发送邮件的功能；
创建 Maven Java 项目：java_spring；
pom 引入 spring-context 依赖；

 
<!-- context -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.6.RELEASE</version>
</dependency>

在 service 包下，创建 EmailService、UserService 以及各自实现类；

 
public interface EmailService {
    void sendEmail();
}
public class EmailServiceImpl implements EmailService {
    public void sendEmail() {
        System.out.println("==== Send email ====");
    }
}
public interface UserService {
    void register(String email, String password);
}
public class UserServiceImpl implements UserService {
    private EmailService emailService;
    // 通过 set 方法注入 emailService
    public void setEmailService(EmailService emailService) {
        this.emailService = emailService;
    }
    public void register(String email, String password) {
        System.out.println("==== Register user ====");
        emailService.sendEmail();
    }
}

在 resources 包下，我们需要编写一个特定的 application.xml 配置文件，告诉 IOC 容器应该如何创建并组装 Bean；

xmlns：命名空间，为了 Spring 的配置文件增加的节点合法，而引入校验该 xml 的格式文件；
xmlns:xsi：XML Schema 实例，声明后就可以使用 schemaLocation 属性；
xsi:schemaLocation：声明目标名称空间的模式文档；
xmlns:context：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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- 每个 bean 都有一个 id 标识，class 指向我们写的 bean 类全路径名 -->
    <bean id="emailService" class="com.sfac.spring.service.impl.EmailServiceImpl" />
    <bean id="userService" class="com.sfac.spring.service.impl.UserServiceImpl">
        <!-- 通过 property 注入另外一个 bean -->
        <property name="emailService" ref="emailService" />
    </bean>
</beans>

上述配置用 Java 代码写出来，就像这样 ---- 不过，IOC 是通过读取 application.xml 文件，通过反射实现的；

 
EmailService emailService = new EmailServiceImpl();
UserService userService = new UserServiceImpl();
userService.setEmailService(emailService);

我们需要创建一个 IOC 容器实例，读取配置文件，并装配 Bean，在基础包下创建 JavaSpringApplication，作为程序入口；

 
public class JavaSpringApplication {
    public static void main(String[] args) {
        ApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("application.xml");
        UserService userService = applicationContext.getBean(UserServiceImpl.class);
        userService.register("hujiang", "111111");
    }
}

流程：XML 配置文件把我们的 Bean 的依赖关系描述出来 ---- IOC 容器读取配置文件，创建并装配 Bean ---- 从容器中获取 Bean 并使用它们；

注解装配 Bean

使用 XML 配置的方式装配 Bean，好处是 Bean 之间的依赖关系一目了然，缺点是比较繁琐，每写一个 Bean，都需要将它写到 Xml 配置文件中，那么有没有其他更简单的方式呢？
我们可以选择 Annotation 注解化配置，完全不需要 XML，让 Spring 自动扫描并组装它们，下面，我们对上面的工程进行改造；
MailService

@Component 注解就相当于定义了一个 Bean，默认 id 为小写开头的类名；
1
@Component public class EmailServiceImpl implements EmailService { }
1
@Component
2
public class EmailServiceImpl implements EmailService {
3
}
2

UserService

@Autowired 就相当于把指定类型的 Bean 注入到指定的属性中，可以写到属性上、set 方法上、构造器的参数上；

 
@Component
public class UserServiceImpl implements UserService {
    @Autowired
    private EmailService emailService;
}

SpringIocTest

启动类上添加两个注解：@Configuration、@ComponentScan；
@Configuration：我们用的 IOC 容器实例是 AnnotationConfigApplicationContext，它需要一个带有 @Configuration 注解的类模板；
@ComponentScan：它告诉容器，自动搜索当前类所在的包以及子包，把所有标注为 @Component 的 Bean 自动创建出来，并根据 @Autowired 进行装配；

 
@Configuration
@ComponentScan
public class SpringIocTest {
    public static void main(String[] args) {
        // 通过读取xml的方式，ClassPath，对应到 target 下 classes 文件夹中的内容
        // ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
        // 通过注解的方式装配 Bean
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringIocTest.class);
        UserService userService = applicationContext.getBean(UserService.class);
        userService.register("admin1@163.com", "111111");
    }
}

注意项目的结构

通过改造我们发现，使用注解的方式，无需用到 application.xml 配置，大幅简化了 Spring 配置；

定制 Bean

@Component：单例模式（Singleton）创建 Bean，容器初始化时创建，容器销毁时销毁，每次从容器中获取到的 Bean 是同一个实例；

 
@Component
public class MailService {
    …………
}

@Scope：原型模式（Prototype）创建 Bean，每次从容器中获取到的是一个新的实例；

 
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE) // @Scope("prototype")
public class MailService {
    …………
}

@Bean 单例模式创建第三方 Bean，在 @Configuration 类中编写一个 Java 方法创建并返回它，给方法标记一个 @Bean 注解，如果需要注入多个实例，给每个 Bean 加上别名；

 
@Configuration
@ComponentScan
public class SpringIocTest {
    @Primary
    @Bean
    // 指定 Bean 别名的方式二，@Bean + @Qualifier
    //@Bean
    //@Qualifier("utc8")
    ZoneId zoneIdShanghai() {
        return ZoneId.of("UTC+08:00");
    }
    // 指定 Bean 别名的方式一
    @Bean("utc")
    ZoneId zoneIdBase() {
        return ZoneId.of("UTC+00:00");
    }
    …………
}

Bean 注入方式

1
// 按照 bean 类型注入，找不到则忽略 @Autowired(required = false) private ZoneId zoneId = ZoneId.systemDefault(); // 按照 bean 名字注入 @Resource(name = "utc8") private ZoneId zoneIdUtc8;
1
// 按照 bean 类型注入，找不到则忽略
2
@Autowired(required = false)
3
private ZoneId zoneId = ZoneId.systemDefault();
4
// 按照 bean 名字注入
5
@Resource(name = "utc8")
6
private ZoneId zoneIdUtc8;
2

注入 List

 
public interface Validator {
    void validate(String email, String password);
}
// @Order 为多个 Bean 设置优先级
@Component
@Order(1)
public class EmailValidator implements Validator {
    @Override
    public void validate(String email, String password) {
        if (!email.matches("^[a-z0-9]+\\@[a-z0-9]+\\.[a-z]{2,10}$")) {
            throw new IllegalArgumentException("invalid email: " + email);
        }
    }
}
@Component
@Order(2)
public class PasswordValidator implements Validator {
    @Override
    public void validate(String email, String password) {
        if (!password.matches("^.{6,20}$")) {
            throw new IllegalArgumentException("invalid password");
        }
    }
}
@Component
public class Validators {
    @Autowired
    private List<Validator> list;
    public void validate(String email, String password) {
        for (Validator validator : list) {
            validator.validate(email, password);
        }
    }
}

@Value 注入资源文件；

在 resources 包下创建 jdbc-parms.properties 配置文件，配置数据库信息；

1
jdbc.driverClassName=com.mysql.jdbc.Driver jdbc.url=jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf8&useSSL=false jdbc.username=root jdbc.password=root
1
jdbc.driverClassName=com.mysql.jdbc.Driver
2
jdbc.url=jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf8&useSSL=false
3
jdbc.username=root
4
jdbc.password=root
2

创建 ConfigUtil 类读取资源文件；

 
@Component
public class ConfigUtil {
    @Value("classpath:/jdbc-parms.properties") // classpath 方式
    //@Value("file:/temp/jdbc-parms.properties") // 指定文件路径的方式
    private Resource resource;
    public Properties getProperties() {
        Properties properties = new Properties();
        try {
            properties.load(resource.getInputStream());
        } catch (IOException e) {
            e.printStackTrace();
        }
        return properties;
    }
}

在其他 Bean 注入 ConfigUtil 并获得配置信息；

1
Properties properties = configUtil.getProperties(); System.out.println(properties.getProperty("jdbc.url"));
1
Properties properties = configUtil.getProperties();
2
System.out.println(properties.getProperty("jdbc.url"));
2

@PropertySource 自动装配配置文件；

 
@Component
@PropertySource("classpath:jdbc-parms.properties")
public class JdbcParams {
    // 如果 jdbc.driverClassName 不存在，则使用冒号后面的默认值，默认值无需加引号
    @Value("${jdbc.driverClassName:defaultValue}")
    private String driverClassName;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String userName;
    @Value("${jdbc.password}")
    private String password; 
    …………
}
// UserService
@Autowired
private JdbcParams jdbcParams;
System.out.println(jdbcParams.getDriverClassName());

条件装配 Bean

@Profile：Spring 为应用程序准备了 Profile 这一概念，用来表示不同的环境，比如 dev、staging、live 三个环境；

1
@Primary @Bean @Profile("!dev") // 非 dev 环境创建 ZoneId zoneIdShanghai() { return ZoneId.of("UTC+08:00"); } @Bean("utc") @Profile("dev") // dev 环境创建 ZoneId zoneIdBase() { return ZoneId.of("UTC+00:00"); }
1
@Primary
2
@Bean
3
@Profile("!dev") // 非 dev 环境创建
4
ZoneId zoneIdShanghai() {
5
return ZoneId.of("UTC+08:00");
6
}
7
8
@Bean("utc")
9
@Profile("dev") // dev 环境创建
10
ZoneId zoneIdBase() {
11
return ZoneId.of("UTC+00:00");
12
}
2

@Conditional 条件决定是否创建 Bean，***.class，需要实现 Condition 接口，具体逻辑需要自己实现；

1
@Component //@Conditional(***.class) public class ConfigUtil { }
1
@Component
2
//@Conditional(***.class)
3
public class ConfigUtil {
4
}
2

Bean 生命周期

简介：Spring Bean 的完整生命周期从创建 Spring 容器开始，直到最终 Spring 容器销毁 Bean；
实例化 && 初始化；

实例化：声明一个对象或者变量，开辟一个内存空间；
初始化：给对象或变量赋值；

四个阶段

 
// 前三个阶段容纳到 AbstractAutowireCapableBeanFactory doCreateBean 方法中
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
        throws BeanCreationException {
    // Instantiate the bean.
    BeanWrapper instanceWrapper = null;
    if (instanceWrapper == null) {
        // 实例化阶段
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    // Initialize the bean instance.
    Object exposedObject = bean;
    try {
        // 属性赋值阶段
        populateBean(beanName, mbd, instanceWrapper);
        // 初始化阶段
        exposedObject = initializeBean(beanName, exposedObject, mbd);
    } catch (Throwable ex) {
    }
    return exposedObject;
}

2
实例化 Instantiation ---- createBeanInstance()；
属性赋值 Populate ---- populateBean()；
初始化 Initialization ---- initializeBean()；
销毁 Destruction ---- 容器关闭时调用，调用 ConfigurableApplicationContext ---- close()；

扩展点_影响多个类的接口

InstantiationAwareBeanPostProcessor；

作用于实例化阶段前后；

// AbstractAutowireCapableBeanFactory.class
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
		throws BeanCreationException {
	try {
		// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
		// postProcessBeforeInstantiation 方法调用点
        // for循环调用所有的InstantiationAwareBeanPostProcessor
		// 在 doCreateBean 方法之前调用
		// 该方法的返回值会替换原本的Bean作为代理，这也是Aop等功能实现的关键点
		Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
		if (bean != null) {
			return bean;
		}
	} catch (Throwable ex) {
	}
	try {
		Object beanInstance = doCreateBean(beanName, mbdToUse, args);
		if (logger.isTraceEnabled()) {
			logger.trace("Finished creating instance of bean '" + beanName + "'");
		}
		return beanInstance;
	} catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
	}
}
// AbstractAutowireCapableBeanFactory.class
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
	// postProcessAfterInstantiation 调用点
    // 方法作为属性赋值的前置检查条件，在属性赋值之前执行
    // 返回值为boolean，返回 false 时可以阻断属性赋值阶段
    boolean continueWithPropertyPopulation = true;
	if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
		for (BeanPostProcessor bp : getBeanPostProcessors()) {
			if (bp instanceof InstantiationAwareBeanPostProcessor) {
				InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
				if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
					continueWithPropertyPopulation = false;
					break;
				}
			}
		}
	}
}

 
// AbstractAutowireCapableBeanFactory.class
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
        throws BeanCreationException {
    try {
        // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
        // postProcessBeforeInstantiation 方法调用点
        // for循环调用所有的InstantiationAwareBeanPostProcessor
        // 在 doCreateBean 方法之前调用
        // 该方法的返回值会替换原本的Bean作为代理，这也是Aop等功能实现的关键点
        Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
        if (bean != null) {
            return bean;
        }
    } catch (Throwable ex) {
    }
    try {
        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
        if (logger.isTraceEnabled()) {
            logger.trace("Finished creating instance of bean '" + beanName + "'");
        }
        return beanInstance;
    } catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
    }
}
// AbstractAutowireCapableBeanFactory.class
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
    // postProcessAfterInstantiation 调用点
    // 方法作为属性赋值的前置检查条件，在属性赋值之前执行
    // 返回值为boolean，返回 false 时可以阻断属性赋值阶段
    boolean continueWithPropertyPopulation = true;
    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                    continueWithPropertyPopulation = false;
                    break;
                }
            }
        }
    }
}

BeanPostProcessor

在初始化前后调用；
BeanPostProcessor 也会注册为 Bean，那么 Spring 是如何保证 BeanPostProcessor 在我们的业务 Bean 之前初始化完成呢？

// AbstractApplicationContext.class
public void refresh() throws BeansException, IllegalStateException {
	synchronized (this.startupShutdownMonitor) {
		// Allows post-processing of the bean factory in context subclasses.
		postProcessBeanFactory(beanFactory);
		// Invoke factory processors registered as beans in the context.
		invokeBeanFactoryPostProcessors(beanFactory);
		// Register bean processors that intercept bean creation.
		// 所有 BeanPostProcesser 初始化的调用点
		registerBeanPostProcessors(beanFactory);
		// Initialize message source for this context.
		initMessageSource();
		// Initialize event multicaster for this context.
		initApplicationEventMulticaster();
		// Initialize other special beans in specific context subclasses.
		onRefresh();
		// Check for listener beans and register them.
		registerListeners();
		// Instantiate all remaining (non-lazy-init) singletons.
		// 所有单例非懒加载 Bean 的调用点
		finishBeanFactoryInitialization(beanFactory);
		// Last step: publish corresponding event.
		finishRefresh();
	}
}

 
// AbstractApplicationContext.class
public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        // Allows post-processing of the bean factory in context subclasses.
        postProcessBeanFactory(beanFactory);
        // Invoke factory processors registered as beans in the context.
        invokeBeanFactoryPostProcessors(beanFactory);
        // Register bean processors that intercept bean creation.
        // 所有 BeanPostProcesser 初始化的调用点
        registerBeanPostProcessors(beanFactory);
        // Initialize message source for this context.
        initMessageSource();
        // Initialize event multicaster for this context.
        initApplicationEventMulticaster();
        // Initialize other special beans in specific context subclasses.
        onRefresh();
        // Check for listener beans and register them.
        registerListeners();
        // Instantiate all remaining (non-lazy-init) singletons.
        // 所有单例非懒加载 Bean 的调用点
        finishBeanFactoryInitialization(beanFactory);
        // Last step: publish corresponding event.
        finishRefresh();
    }
}

执行顺序，引入排序相关的接口 PriorityOrdered、Ordered；

PriorityOrdered 是一等公民，首先被执行，PriorityOrdered 公民之间通过接口返回值排序；
Ordered 是二等公民，然后执行，Ordered 公民之间通过接口返回值排序；
都没有实现是三等公民，最后执行；

扩展点_只调用一次的接口

Aware 接口

简介：无所不知的 Aware，作用就是让我们能够拿到 Spring 容器中的一些资源，命名见名知意，在初始化阶段之前调用；
Aware Group 1

Bean**Aware ---- 在代码中直接调用；
BeanNameAware
BeanClassLoaderAware
BeanFactoryAware

Aware Group 2

EnvironmentAware
EmbeddedValueResolverAware：这个知道的人可能不多，实现该接口能够获取 Spring EL 解析器，用户的自定义注解需要支持 spel 表达式的时候可以使用，非常方便；
ApplicationContextAware（ResourceLoaderAware、ApplicationEventPublisherAware、MessageSourceAware）：这几个接口可以一起记，其返回值实质上都是当前的 ApplicationContext 对象，因为 ApplicationContext 是一个复合接口，通过 BeanPostProcessor#postProcessBeforeInitialization() 实现；

源码分析

 
// AbstractAutowireCapableBeanFactory.class
protected Object initializeBean(final String beanName, final Object bean, 
                                @Nullable RootBeanDefinition mbd) {
    // 调用 Group1 中的 Aware
    invokeAwareMethods(beanName, bean);
    // 调用 Group2 中的 Aware
    // 实质上这里就是前面所说的 BeanPostProcessor 的调用点
    // 与 Group1 不同，是通过 BeanPostProcessor（ApplicationContextAwareProcessor）实现的
    Object wrappedBean = bean;
    wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    // 下文即将介绍的 InitializingBean 调用点
    invokeInitMethods(beanName, wrappedBean, mbd);
    // BeanPostProcessor的另一个调用点
    wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    return wrappedBean;
}

生命周期接口

InitializingBean

对应生命周期的初始化阶段，在上面源码的 invokeInitMethods 方法中调用；
因为 Aware 方法都是执行在初始化方法之前，所以可以在初始化方法中放心大胆的使用 Aware 接口获取的资源，这也是我们自定义扩展 Spring 的常用方式；

DisposableBean

类似于 InitializingBean，对应生命周期的销毁阶段，以 ConfigurableApplicationContext#close() 方法作为入口，实现是通过循环取所有实现了 DisposableBean 接口的 Bean 然后调用其 destroy() 方法；

组件体系

Resource 体系：对资源的抽象，它的每一个实现类都代表了一种资源的访问策略，如 ClasspathResource 、 URLResource ，FileSystemResource 等，利用 ResourceLoader 来进行统一资源加载；
BeanDefinitionReader 体系：它的作用是读取 Spring 的配置文件的内容，并将其转换成 Ioc 容器内部的数据结构 BeanDefinition；
BeanDefinition 体系：用来描述 Spring 中的 Bean 对象；
BeanFactory 体系：Bean 容器，它是 IOC 必备的数据结构，其中 BeanDefinition 是它的基本结构，它内部维护着一个 BeanDefinitionMap ，并可根据 BeanDefinition 的描述进行 Bean 的创建和管理；
ApplicationContext 体系：大名鼎鼎的 Spring 容器，它叫做应用上下文，与我们应用息息相关，她继承 BeanFactory、继承 MessageSource（提供国际化的标准访问策略）、继承 ApplicationEventPublisher（提供强大的事件机制）、扩展 ResourceLoader（可以用来加载多个 Resource，可以灵活访问不同的资源）、对 Web 应用的支持；

循环依赖

介绍

分类：自身依赖于自身、互相循环依赖、多组循环依赖；
无论循环依赖的数量有多少，其本质是一样的，就是你创建时依赖我，而我创建也依赖于你，但我们互相没法解耦，最终导致依赖创建失败，Spring 提供了 setter 循环依赖注入解决方案；

方案

思路：让类的创建和属性的填充分离，先创建出半成品 Bean，再处理属性的填充，最终提供完整的 Bean；
相互循环依赖代码；

 
@Service
public class TestService1 {
    @Autowired
    public TestService2 testService2;
    public void test1() {
    }
}
@Service
public class TestService2 {
    @Autowired
    private TestService1 testService1;
    public void test2() {
    }
}

Spring 内部三级缓存；

SingletonObjects：一级缓存，用于保存实例化、注入、初始化完成的 Bean 实例 ---- Bean 成品；
EarlySingletonObjects：二级缓存，用于保存实例化完成的 Bean 实例 ---- Bean 半成品；
SingletonFactories：三级缓存，用于保存 Bean 创建工厂，以便于后面扩展有机会创建代理对象；

流程图

AOP 切面编程

简介

先来回顾下 OOP，Object Oriented Programming，面向对象编程，主要特征：封装、继承、多态；
Aspect Oriented Programming，面向切面编程，AOP 将系统分解成不同的关注点，或者称之为切面；
我们先以 OOP 举个栗子，比如一个业务组件 UserService，它又几个业务方法；

createUser ---- 创建用户；
updateUser ---- 更新用户；
deleteUser ---- 删除用户；

对每个业务方法，除了 user 相关的业务之外，还需要安全检查、日志记录、事务处理等功能；

 
public class UserService {
    public void createUser(User user) {
        securityCheck();
        Transaction tx = startTransaction();
        try {
            // user相关业务
            tx.commit();
        } catch (RuntimeException e) {
            tx.rollback();
            throw e;
        }
        log("created user: " + user);
    }
}

同理，updateUser、deleteUser 也有类似的代码，使用 OOP 编程，很难将这些四处分散的代码模块化；
不难发现，这些功能“横跨”了多个业务方法，我们将这些业务流中公共的部分抽取出来单独封装，形成独立的切面，在合适的时机将这些切面横向切入到业务流程指定的位置中；

原理

静态代理

代理类中有被代理类的引用，在代理类的方法中进行功能增强；

 
public class UserServiceProxy extends UserService {
    private UserService target;
    @Override
    public User register(String email, String password) {
        // do something like securityCheck, transaction, log
        return target.register(email, password);
    }
}

动态代理

利用 InvocationHandler 接口和 Proxy 类生成“动态代理类” 和“代理对象”，在运行时利用反射机制创建代理类，并进行功能增强；

public class InvocationHandlerImpl<T> implements InvocationHandler {
    private T target;
    public InvocationHandlerImpl(T target) {
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // do something like securityCheck, transaction, log
        System.out.println("---------------");
        Object result = method.invoke(target, args);
        System.out.println("---------------");
        return result;
    }
    public static void main(String[] args) {
        // 创建被代理类
        UserService target = new UserServiceImpl();
        // 创建 InvocationHandler 动态代理类
        InvocationHandlerImpl<UserService> invocationHandlerImpl = new InvocationHandlerImpl<UserService>(target);
        // 创建代理对象
        UserService userService = (UserService) Proxy.newProxyInstance(
            	UserService.class.getClassLoader(), 
                new Class<?>[] {UserService.class}, 
            	invocationHandlerImpl);
        // 代理对象调用方法，进行增强
        userService.getUserByUserNameAndPassword("hyman", "111111");
    }
}

 
public class InvocationHandlerImpl<T> implements InvocationHandler {
    private T target;
    public InvocationHandlerImpl(T target) {
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // do something like securityCheck, transaction, log
        System.out.println("---------------");
        Object result = method.invoke(target, args);
        System.out.println("---------------");
        return result;
    }
    public static void main(String[] args) {
        // 创建被代理类
        UserService target = new UserServiceImpl();
        // 创建 InvocationHandler 动态代理类
        InvocationHandlerImpl<UserService> invocationHandlerImpl = new InvocationHandlerImpl<UserService>(target);
        // 创建代理对象
        UserService userService = (UserService) Proxy.newProxyInstance(
                UserService.class.getClassLoader(), 
                new Class<?>[] {UserService.class}, 
                invocationHandlerImpl);
        // 代理对象调用方法，进行增强
        userService.getUserByUserNameAndPassword("hyman", "111111");
    }
}

如何将切面横切到业务流中？在 Java 平台上，对于 AOP 织入，有三种方式；

编译期：在编译时，由编译器把切面调用编译进字节码，这种方式需要定义新的关键字并扩展编译器，AspectJ 就扩展了 Java 编译器，使用关键字 aspect 来实现织入；
类加载器：在目标类被装载到 JVM 时，通过一个特殊的类加载器，对目标类的字节码重新“增强”；
运行期：目标对象和切面都是普通 Java 类，通过 JVM 的动态代理功能或者第三方库实现运行期动态织入；

Spring AOP 就是基于 JVM 动态代理来实现的，JVM 的动态代理要求必须实现接口，如果一个普通类没有业务接口，就需要通过 CGLIB 或者 Javassist 这些第三方库实现；
AOP 技术看上去比较神秘，但实际上，它本质就是一个动态代理，让我们把一些常用功能如权限检查、日志、事务等，从每个业务方法中剥离出来；
需要特别指出的是，AOP 对于解决特定问题，例如事务管理非常有用，这是因为分散在各处的事务代码几乎是完全相同的，并且它们需要的参数（JDBC 的 Connection）也是固定的，另一些特定问题，如日志，就不那么容易实现，因为日志虽然简单，但打印日志的时候，经常需要捕获局部变量，如果使用 AOP 实现日志，我们只能输出固定格式的日志，因此，使用 AOP 时，必须适合特定的场景；

注解和参数

@Aspect：切面程序；
@Pointcut：切点，具体定位的连接点；
@Order(1)：优先级，数字越小优先级越高；
增强/通知（Advice）：

@Before：前置通知, 在方法执行之前执行；
@After：最终通知, 在方法执行之后执行；
@AfterRunning：返回通知, 在方法返回结果之后执行；
@AfterThrowing：异常通知, 在方法抛出异常之后；
@Around：环绕通知, 围绕着方法执行；

----------------------------
JoinPoint：封装了 Spring Aop 中切面方法的信息，可在切面方法中添加该参数；

getSignature()：签名信息，可获得目标方法名，所属类的 Class 信息；
getArgs()：目标方法的参数；
getTarget()：被代理对象；
getThis()：代理对象；

ProceedingJoinPoint：JoinPoint 的子接口，该对象只用在 @Around 的切面方法中；

proceed()：执行目标方法；
proceed(Object[] var1)：带参执行目标方法；

实现方式

基于代理的经典 SpringAOP：需要实现接口，手动创建代理；
纯 POJO 切面：使用 XML 配置，Aop 命名空间；
@Aspect 注解驱动的切面：使用注解方式，这是最简洁和最方便；
----------------

pom 引入 jar；

 
<!-- Spring AOP -->
<dependency>  
    <groupId>org.springframework</groupId>  
    <artifactId>spring-aop</artifactId>  
    <version>${spring.version}</version>  
</dependency>
<!-- 支持切入点表达式 -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>${aspectj.version}</version>
</dependency>
<!-- 支持 aop 注解 -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjrt</artifactId>
    <version>${aspectj.version}</version>
</dependency>

切面类 MethodLoggerAspect.java

添加 @Aspect、@Component 注解；
切面类添加切点方法，添加 @Pointcut、@Order(1) 注解；

切点设置方式一：绑定表达式，execution(public * com.sfac.springMvc.module.*.service.*.*(..))，大面积绑定；
切点设置方式二：绑定注解，@annotation(com.sfac.springMvc.aspect.MethodInfoAnnotation)，精确绑定，在需要增强的地方添加注解即可；

切面类中定义增强方法，选择添加 @Before、@Around、@After 等注解，并和切点方法绑定，注意，增强方法参数为 JoinPoint 或其子类；

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MethodInfoAnnotation {
}
@Component
@Aspect
public class MethodLoggerAspect {
	private final static Logger LOGGER = LogManager.getLogger(MethodLoggerAspect.class);
	private ObjectMapper mapper = new ObjectMapper();

/**
     * -第一个*代表返回类型不限
     * -第二个*代表 module 包下所有子包
     * -第三个*代表 server 包下所有类
     * -第四个*代表所有方法
     * (..) 代表参数不限
     * Order 代表优先级，数字越小优先级越高
     * -多个表达式之间使用 ||, or 表示或 ，使用 && , and 表示与 ， ！表示非
     */
	@Pointcut("execution(public * com.sfac.springMvc.module.*.service.*.*(..)) || "
			+ "@annotation(com.sfac.springMvc.aspect.MethodInfoAnnotation)")
//	@Pointcut("@annotation(com.sfac.springMvc.aspect.MethodInfoAnnotation)")
//	@Pointcut("execution(public * com.sfac.springMvc.module.*.service.*.*(..))")
	@Order(1)
	public void methodLoggerPointCut() {}
	
	@Before(value = "methodLoggerPointCut()")
	public void beforeAspect(JoinPoint joinPoint) throws JsonProcessingException {
		LOGGER.debug("======== Before Aspect ========");
		String className = joinPoint.getTarget().getClass().getName();
		String methodName = joinPoint.getSignature().getName();
		Object[] args = joinPoint.getArgs();
        // 有些参数无法 Json 序列化
		//List<String> argsList = new ArrayList<String>();
		//for (Object item : args) {
		//	argsList.add(mapper.writeValueAsString(item));
		//}
		LOGGER.debug(String.format("Call class: %s", className));
		LOGGER.debug(String.format("Call method: %s", methodName));
        if (args.length > 0) {
			LOGGER.debug(String.format("Call method args: %s", args));
		}
	}
	
	@Around(value = "methodLoggerPointCut()")
	public Object aroundAspect(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
		long startTime = System.currentTimeMillis();
		Object result = proceedingJoinPoint.proceed(proceedingJoinPoint.getArgs());
		long endTime = System.currentTimeMillis();
		LOGGER.debug(String.format("Elapse time: %s millisecond", (endTime - startTime)));
		return result;
	}
	
	@After(value = "methodLoggerPointCut()")
	public void afterAspect(JoinPoint joinPoint) {
		LOGGER.debug("======== After Aspect ========");
	}
}

 
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MethodInfoAnnotation {
}
@Component
@Aspect
public class MethodLoggerAspect {
    private final static Logger LOGGER = LogManager.getLogger(MethodLoggerAspect.class);
    private ObjectMapper mapper = new ObjectMapper();
    /**
     * -第一个*代表返回类型不限
     * -第二个*代表 module 包下所有子包
     * -第三个*代表 server 包下所有类
     * -第四个*代表所有方法
     * (..) 代表参数不限
     * Order 代表优先级，数字越小优先级越高
     * -多个表达式之间使用 ||, or 表示或 ，使用 && , and 表示与 ， ！表示非
     */
    @Pointcut("execution(public * com.sfac.springMvc.module.*.service.*.*(..)) || "
            + "@annotation(com.sfac.springMvc.aspect.MethodInfoAnnotation)")
//  @Pointcut("@annotation(com.sfac.springMvc.aspect.MethodInfoAnnotation)")
//  @Pointcut("execution(public * com.sfac.springMvc.module.*.service.*.*(..))")
    @Order(1)
    public void methodLoggerPointCut() {}
    
    @Before(value = "methodLoggerPointCut()")
    public void beforeAspect(JoinPoint joinPoint) throws JsonProcessingException {
        LOGGER.debug("======== Before Aspect ========");
        String className = joinPoint.getTarget().getClass().getName();
        String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        // 有些参数无法 Json 序列化
        //List<String> argsList = new ArrayList<String>();
        //for (Object item : args) {
        //  argsList.add(mapper.writeValueAsString(item));
        //}
        LOGGER.debug(String.format("Call class: %s", className));
        LOGGER.debug(String.format("Call method: %s", methodName));
        if (args.length > 0) {
            LOGGER.debug(String.format("Call method args: %s", args));
        }
    }
    
    @Around(value = "methodLoggerPointCut()")
    public Object aroundAspect(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        long startTime = System.currentTimeMillis();
        Object result = proceedingJoinPoint.proceed(proceedingJoinPoint.getArgs());
        long endTime = System.currentTimeMillis();
        LOGGER.debug(String.format("Elapse time: %s millisecond", (endTime - startTime)));
        return result;
    }
    
    @After(value = "methodLoggerPointCut()")
    public void afterAspect(JoinPoint joinPoint) {
        LOGGER.debug("======== After Aspect ========");
    }
}

配置

Spring Mvc 配置

开启 Spring Aop 注解方式，我们需要在 Spring && SpringMvc 配置文件同时开启，因为两个配置文件开启注解扫描的区域不一样，SpringMvc 负责 Controller，Spring 负责其他，而 Aop 程序可以和注解绑定，并不确定放到哪一层代码上；
applicationContext.xml && springMvcConfig.xml

<aop:aspectj-autoproxy />

Spring Boot 配置

启动类上添加 @EnableAspectJAutoProxy 注解，意思是让 AOP 容器扫描标有 @Aspect 的 Bean，然后根据 Bean 中配置的切点将增强方法织入到业务流中；

源码解读

aop:aspectj-autoproxy 标签

Spring Aop 标签解析调用 AopNamespaceHandler.java；

遇到 <aop:aspectj-autoproxy/> 标签时会调用 AspectJAutoProxyBeanDefinitionParser.java 的 parse 来解析；

AopNamespaceUtils.java

Spring 提供了 JDK 代理和 CGLIB 代理

JDK 代理：基于接口，接口方法被代理，其余方法不被代理；
CGLIB 代理：基于类，不能被继承的方法（final、private）不被代理;

Aop 的默认方式 JDK 代理，如果目标对象只是一个类，会自动转为 CGLIB 代理；
proxy-target-class 设置为 true，表示强制使用 CGLIB 代理；
expose-proxy 用来解决对象内部 this 调用无法被切面增强的问题，例如我们在 A 类的对象内部 x 方法中调用另外一个内部方法 y 时，y 方法不会被切面增强，这时可以配置 expose-proxy 为 true 并将 this.y() 改为 ((A)AopContext.currentProxy()).y()，即可让 y 方法被切面增强；

Spring 事务

事务分类

编码式事务：通过编码的方式实现事务；
声明式事务：基于 Spring AOP，将具体的业务逻辑和事务解耦；

在 Xml 配置文件中做事务规则声明；

 
<tx:annotation-driven />
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource" />
</bean>

基于 @Transactional 注解的方式，是目前流行的方式；

javax.transaction.Transactional；
org.springframework.transaction.annotation.Transactional；
二者都能进行事务控制，但用法有区别，查看源码可知，Spring 的注解属性稍多，提供 propagation 等注解；

事务的传播机制

保证同一个事务中

TransactionDefinition.PROPAGATION_REQUIRED ---- 如果当前存在事务，则加入该事务，如果当前没有事务，则创建一个新的事务，这是默认值；
TransactionDefinition.SUPPORTS ---- 支持当前事务，如果不存在，就不使用事务；
TransactionDefinition.MANDATORY ---- 支持当前事务，如果不存在，抛出异常；

保证没有在同一个事务中

TransactionDefinition.REQUIRES_NEW ---- 如果有事务存在，挂起当前事务，创建一个新的事务，新的执行完毕，继续执行老的事务；
TransactionDefinition.NOT_SUPPORTED ---- 以非事务方式运行，如果有事务存在，挂起当前事务；
TransactionDefinition.NEVER ---- 以非事务方式运行，如果有事务存在，抛出异常；
PROPAGATION_NESTED ---- 如果当前事务存在，则嵌套事务执行；

隔离级别

DEFAULT ---- 使用数据库默认隔离级别；
未提交读 ---- 脏读，不可重复读，虚读都有可能发生；
已提交读 ---- 避免脏读，但是不可重复读和虚读有可能发生；
可重复读 ---- 避免脏读和不可重复读，但是虚读有可能发生；
串行化的 ---- 避免所有问题；

应用

@Transactional 只能加到 public 修饰的类或方法上，如果加到类上，将整个类纳入事务，每个方法调用都会开启一个事务，使用同一个规则；
@Transactional 注解的方法，如果抛出运行时异常或 Error，那么会进行事务回滚；

SQL 异常、IOException 异常属于检查异常，默认情况 Spring 事务对检查异常不会回滚；
Catch 异常后再抛出异常，事务以新抛出异常为判断依据是否回滚；
Catch 后不抛出异常，同样不会回滚；

@Transactional(propagation = Propagation.REQUIRED, readOnly = false, rollbackFor=MyException.class)
@Transactional(transactionManager="mainDbTransactionManager") ---- 如果配置有多个事务管理器，则需要指定具体的管理器；

propagation：事务的传播行为，默认值为 REQUIRED；
isolation：事务的隔离度，默认 DEFAULT；
timeout：超时时间，默认-1，不超时；
read-only：指定事务是否为只读，过滤那些不需要事务的方法；
rollbackFor：用于指定能够触发事务回滚的异常类型，多个{xxx1.class, xxx2.class,……}
noRollbackFor：指定不回滚事务的异常，多个写法如上；

================================
一个事务里面，Debug 未完成，数据不会入库；
一个事务里面，执行到一半，停掉程序，数据会回滚；
一个事务里面，可以对同一条数据进行多次增删改查；
一个非事务方法，调用了事务方法，不会回滚数据；

Spring AOP是动态代理实现的，事务控制语句在代理对象的事务方法上，代理对象调用非事务方法（转到原生非事务方法上 ---- 调用原生事务方法 ---- 没有事务控制语句），是没有事务的；

多线程操作同一事务，看传播机制，底层以 ThreadLocal（ThreadLocal 为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本）对 TransactionSynchronizationManager 进行了封装，解决了多线程并发问题；

Spring MVC

简介

首先来回顾下 Servlet 开发；

Servlet 规范定义了几种标准组件：

Servlet：处理 HTTP 请求并将 HTTP 响应返回；
JSP：一种嵌套 Java 代码的 HTML，将被编译为 Servlet；
Filter：能过滤指定的URL以实现拦截功能；
Listener：监听指定的事件，如 ServletContext、HttpSession 的创建和销毁；

Servlet 的标准组件总是运行在 Servlet 容器中，如 Tomcat、Jetty、WebLogic 等；
Servlet 容器为每个 Web 应用程序自动创建一个唯一的 ServletContext 实例，这个实例就代表了 Web 应用程序本身；
直接使用 Servlet 进行 Web 开发好比直接在 JDBC 上操作数据库，比较繁琐，更好的方法是在 Servlet 基础上封装 MVC 框架；
Spring 提供的是一个 IOC 容器，所有的 Bean 都在 Spring IOC 容器中被初始化，而 Servlet 容器由 JavaEE 服务器提供（如 Tomcat），Servlet 容器对 Spring 一无所知，他们之间到底依靠什么进行联系，又是以何种顺序初始化的？

MVC 三层架构

Model View Controller，是 Web 开发中常用的设计思想，以下图为例说明；
Model：模型层，可以是一个 JavaBean，也可以是包含多个对象的 Map，好比 User，不但代表一个实体，还包含了 User 相关的业务处理；
View：视图层，负责将 Model 渲染出来；
Controller：控制层，负责连接视图层和模型层，负责请求和响应绑定、数据传递；

MVC 框架

Struts：最古老的一个 MVC 框架，目前版本是 2，和 1.x 有很大的区别；
WebWork：一个比 Struts 设计更优秀的 MVC 框架，但不知道出于什么原因，从 2.0 开始把自己的代码全部塞给 Struts 2 了；
Turbine：一个重度使用 Velocity，强调布局的 MVC 框架；
Spring MVC：设计得足够优秀，我们已经不想再费劲去集成类似 Struts 这样的框架了；

搭建项目

用 Ide 创建一个 Maven Web 项目，参见 Tool_IDE 步骤，并补全 Web 项目文件夹和包；

src/main/java ---- java source 包；

com.sfac.springMvc ---- 基础包
com.sfac.springMvc.module ---- 模块包，根据业务功能分为不同模块，每个模块下都有 controller、service、dao 等包；
com.sfac.springMvc.module.test.entity ---- test 模块实体包；
com.sfac.springMvc.module.test.controller ---- test 模块控制器包；
com.sfac.springMvc.module.test.service ----- test 模块服务包；
com.sfac.springMvc.module.test.dao ---- test 模块数据操作包；

src/main/resources ---- 配置资源包；
src/main/webapp ---- web 应用资源文件包；

src/main/webapp/static ---- 放置 js、css、image 等静态资源；
src/main/webapp/WEB_INF ---- 放置 web.xml、view 模版文件夹 templates（不允许浏览器直接访问）、编译的 class、第三方 jar；
src/main/webapp/index.jsp ---- web 应用默认主页；

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>4.0.0</modelVersion>
	<groupId>com.sfac</groupId>
	<artifactId>java_spring_mvc</artifactId>
	<packaging>war</packaging>
	<version>0.0.1-SNAPSHOT</version>
	<name>java_spring_mvc Maven Webapp</name>
	<url>http://maven.apache.org</url>
	
	<properties>
        <java.version>1.8</java.version>
		<spring.version>5.2.0.RELEASE</spring.version>
		<aspectj.version>1.9.5</aspectj.version>
		<jackson.version>2.11.3</jackson.version>
		<tomcat.version>9.0.36</tomcat.version>
	</properties>
	
	<dependencies>
		
		<dependency>
		    <groupId>org.springframework</groupId>
		    <artifactId>spring-context</artifactId>
		    <version>${spring.version}</version>
		</dependency>
		
		
        <dependency>  
		    <groupId>org.springframework</groupId>  
		    <artifactId>spring-aop</artifactId>  
		    <version>${spring.version}</version>  
		</dependency>
		
		<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjweaver</artifactId>
			<version>${aspectj.version}</version>
		</dependency>
		
		<dependency>
		    <groupId>org.aspectj</groupId>
		    <artifactId>aspectjrt</artifactId>
		    <version>${aspectj.version}</version>
		</dependency>
		
		
		<dependency>
		    <groupId>org.springframework</groupId>
		    <artifactId>spring-webmvc</artifactId>
		    <version>${spring.version}</version>
		</dependency>
		
		
		<dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-orm</artifactId>  
            <version>${spring.version}</version>  
        </dependency>
        
        
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-lang3</artifactId>
			<version>3.10</version>
		</dependency>
		
		
		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-core</artifactId>
			<version>${jackson.version}</version>
		</dependency>
		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-databind</artifactId>
			<version>${jackson.version}</version>
		</dependency>
		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-annotations</artifactId>
			<version>${jackson.version}</version>
		</dependency>
        
        <dependency>
			<groupId>com.fasterxml.jackson.datatype</groupId>
			<artifactId>jackson-datatype-jsr310</artifactId>
			<version>${jackson.version}</version>
		</dependency>
		
		
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>3.8.1</version>
			<scope>test</scope>
		</dependency>
	</dependencies>
	
	<build>
		<finalName>java_spring_mvc</finalName>
        
        <plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
			    <artifactId>maven-compiler-plugin</artifactId>
			    <version>3.8.1</version>
			    <configuration>
					<source>1.8</source>
					<target>1.8</target>
					<encoding>UTF-8</encoding>
			    </configuration>
			</plugin>
		</plugins>
	</build>
</project>

 
<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>4.0.0</modelVersion>
    <groupId>com.sfac</groupId>
    <artifactId>java_spring_mvc</artifactId>
    <packaging>war</packaging>
    <version>0.0.1-SNAPSHOT</version>
    <name>java_spring_mvc Maven Webapp</name>
    <url>http://maven.apache.org</url>
    
    <properties>
        <java.version>1.8</java.version>
        <spring.version>5.2.0.RELEASE</spring.version>
        <aspectj.version>1.9.5</aspectj.version>
        <jackson.version>2.11.3</jackson.version>
        <tomcat.version>9.0.36</tomcat.version>
    </properties>
    
    <dependencies>
        <!-- Spring IOC -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        
        <!-- Spring AOP -->
        <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-aop</artifactId>  
            <version>${spring.version}</version>  
        </dependency>
        <!-- 支持切入点表达式 -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>${aspectj.version}</version>
        </dependency>
        <!-- 支持 aop 注解 -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>${aspectj.version}</version>
        </dependency>
        
        <!-- Spring Web -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        
        <!-- Spring Data Access -->
        <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-orm</artifactId>  
            <version>${spring.version}</version>  
        </dependency>
        
        <!-- Commons -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.10</version>
        </dependency>
        
        <!-- Jackson -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>${jackson.version}</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>${jackson.version}</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>${jackson.version}</version>
        </dependency>
        <!-- 序列化 LocalDateTime 等时间类 -->
        <dependency>
            <groupId>com.fasterxml.jackson.datatype</groupId>
            <artifactId>jackson-datatype-jsr310</artifactId>
            <version>${jackson.version}</version>
        </dependency>
        
        <!-- Test -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
    
    <build>
        <finalName>java_spring_mvc</finalName>
        
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

web.xml

Spring 的启动是在 Servlet 的基础上的，而 Web 工程的初始是 web.xml，主要配置 Web 项目上下文、监听器、过滤器、Servlet 等信息；

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://java.sun.com/xml/ns/javaee"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
	version="3.0">
	<display-name>Java Spring Mvc Application</display-name>

<welcome-file-list>
		<welcome-file>/index.jsp</welcome-file>
	</welcome-file-list>
	
	
	
	<context-param>
		
		<param-name>contextConfigLocation</param-name>
        <param-value>classpath:config/applicationContext.xml</param-value>
        
	</context-param>
	
	
    
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</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>
        <init-param>
            <param-name>forceEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>characterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    
    
    <servlet>
        <servlet-name>springMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:config/springMvcConfig.xml</param-value>
        </init-param>
        
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

 
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://java.sun.com/xml/ns/javaee"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
    version="3.0">
    <display-name>Java Spring Mvc Application</display-name>
    <!-- welcome page -->
    <welcome-file-list>
        <welcome-file>/index.jsp</welcome-file>
    </welcome-file-list>
    
    <!-- servlet 上下文 -->
    <!-- 指定 spring 配置文件，启动 spring 容器 -->
    <context-param>
        <!-- 启动容器就会加载此处配置的配置文件  
             第一种写法，配置文件放在 src/main/resources 下  
            第二种写法，配置文件放在 /WEB-INF/conf/spring 下
         -->
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:config/applicationContext.xml</param-value>
        <!-- <param-value>/WEB-INF/config/applicationContext.xml</param-value> -->
    </context-param>
    
    <!-- listener -->
    <!-- spring 监听器：启动 Web 容器时，自动装配 ApplicationContext 的配置信息 -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    
    <!-- filter -->
    <!-- 字符过滤器 -->
    <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>
        <init-param>
            <param-name>forceEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>characterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    
    <!-- servlet -->
    <servlet>
        <servlet-name>springMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:config/springMvcConfig.xml</param-value>
        </init-param>
        <!-- 值大于等于0表示容器启动应用时候加载该servlet，数值越小优先级越高 -->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

applicationContext.xml

Spring 上下文配置文件；
使用的是 ContextLoaderListener，一般会加载整个 Spring 容器相关的 Bean，例如：Log、Service、Dao、PropertiesLoader、DataSource、Transactional etc.
为什么要设置黑名单，不扫描 Controller？

启动项目时先加载 Spring 上下文配置，后加载 MVC 配置，在 MVC 配置中，需要扫描 MVC 相关的 Bean，如果扫描到 Spring 容器已经装载过的 Bean，也会重新加载，并覆盖 Spring 容器配置的 Bean，但 SpringMvc 加载的 Bean 是没有事务配置的（事务配置在 Spring 上下文中），从而导致 Controller 层在注入 Service 时，实际注入的是 SpringMvc 重新装配的无事务的 Service 实例，会导致注解事务失效；
解决方案

Spring 上下文设置黑名单，不扫描 Controller，扫描其余的 Bean；
SpringMvc 设置白名单，只扫描 Controller；

为了避免该文件杂乱无章，我们按功能将配置拆解成单独的配置文件，applicationContext.xml 的主要任务是

扫描 Spring 容器 Bean；
引入属性文件；
引入其他配置文件；

 
<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans"   
       xmlns:context="http://www.springframework.org/schema/context"   
       xmlns:p="http://www.springframework.org/schema/p"   
       xmlns:mvc="http://www.springframework.org/schema/mvc"   
       xmlns:jee="http://www.springframework.org/schema/jee"   
       xmlns:aop="http://www.springframework.org/schema/aop"   
       xmlns:jaxws="http://cxf.apache.org/jaxws"   
       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-3.0.xsd   
        http://www.springframework.org/schema/context   
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
      
    <!-- 扫描构造型（stereotype）注解所标注的类，@Component、@Repository、@Service、@Controller 等 -->
    <context:component-scan base-package="com.sfac.springMvc">
        <!-- 设置黑名单，不扫描 Controller -->
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>
    
</beans>

springMvcConfig.xml

DispatcherServlet 一般会加载 MVC 相关的 Bean，如: ViewResolver、Controller、MultipartResolver、ExceptionHandler etc.，按照上面的规则，我们只设置白名单，只扫描 Controller，同时把 component-scan 默认过滤关闭，设置 use-default-filters="false"；

<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans"   
       xmlns:context="http://www.springframework.org/schema/context"   
       xmlns:mvc="http://www.springframework.org/schema/mvc"   
       xmlns:p="http://www.springframework.org/schema/p"   
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   
       xmlns:beans="http://www.springframework.org/schema/beans" 
       xmlns:aop="http://www.springframework.org/schema/aop" 
       xsi:schemaLocation="http://www.springframework.org/schema/beans   
        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd   
        http://www.springframework.org/schema/context   
        http://www.springframework.org/schema/context/spring-context-3.0.xsd   
        http://www.springframework.org/schema/mvc   
        http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd 
        http://www.springframework.org/schema/aop
		http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
        
	
	<context:component-scan base-package="com.sfac.springMvc" use-default-filters="false">
		
		<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
	</context:component-scan>
	
	
	<mvc:annotation-driven />
    
	
	<mvc:default-servlet-handler />
	
	
	
    <mvc:resources location="file:D:/upload/" mapping="/upload/**" />
</beans>

 
<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans"   
       xmlns:context="http://www.springframework.org/schema/context"   
       xmlns:mvc="http://www.springframework.org/schema/mvc"   
       xmlns:p="http://www.springframework.org/schema/p"   
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   
       xmlns:beans="http://www.springframework.org/schema/beans" 
       xmlns:aop="http://www.springframework.org/schema/aop" 
       xsi:schemaLocation="http://www.springframework.org/schema/beans   
        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd   
        http://www.springframework.org/schema/context   
        http://www.springframework.org/schema/context/spring-context-3.0.xsd   
        http://www.springframework.org/schema/mvc   
        http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd 
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
        
    <!-- 扫描构造型（stereotype）注解所标注的类，@Component、@Repository、@Service、@Controller 等 -->
    <context:component-scan base-package="com.sfac.springMvc" use-default-filters="false">
        <!-- 设置白名单，只扫描 Controller -->
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>
    
    <!-- 启用注解驱动：将扫描到的组件注册到工厂中，来处理请求；
        Spring 3.0.x 新增配置，其中最主要的两个类：DefaultAnnotationHandlerMapping 和 AnnotationMethodHandlerAdapter，
        分别为 HandlerMapping 的实现类和 HandlerAdapter 的实现类，
        从 3.1.x 版本开始对应实现类改为了 RequestMappingHandlerMapping 和 RequestMappingHandlerAdapter；
        RequestMappingHandlerMapping：处理 @RequestMapping 注解，并将其注册到请求映射表中；
        RequestMappingHandlerAdapter：处理请求的适配器，确定调用哪个类的哪个方法；
    -->
    <mvc:annotation-driven />
    
    <!-- 处理静态资源方式一 
        Spring 3.0.x 新增 REST 风格，URL 不希望带 .html 或 .do 等后缀，在 web.xml 中配置 DispatcherServlet 
        的请求映射为 /，Spring MVC 将捕获 Web 容器所有的请求，包括静态资源的请求，但静态资源没有处理器，因此会报错；
        该配置会在 Spring MVC 上下文中定义一个 DefaultServletHttpRequestHandler，它会像一个检查员，
        对进入 DispatcherServlet 的 URL 进行筛查，如果是静态资源的请求，就将该请求转由 Web 服务器默认的 Servlet 处理，
        如果不是静态资源的请求，才由 DispatcherServlet 继续处理；
        一般 Web 服务器默认的 Servlet 名称是 "default"，因此 DefaultServletHttpRequestHandler 可以找到它，如果你所有的 Web 
        服务器的默认 Servlet 名称不是 "default"，则需要通过 default-servlet-name 属性显示指定；
        该配置从项目 webapp 根目录开始计算路径，假设 webapp 下有 static 文件夹放置 css 和 js，
        那么访问路径类似于：http://127.0.0.1/static/js/custom.js；
    -->
    <mvc:default-servlet-handler />
    
    <!-- 处理静态资源方式二
        该配置在处理静态资源上更进一步，由 Spring MVC 框架自己处理静态资源；
        location：没有前缀，从项目 webapp 根目录开始计算路径，
        访问路径 = 映射路径 + 相对路径，类似于：http://127.0.0.1/static/js/custom.js；
        location: 添加 ‘file:’ 前缀，表示用本地文件夹作为静态资源文件夹，
        访问路径 = 映射路径 + 相对路径，类似于：http://127.0.0.1/upload/test.jpg；
    -->
    <!-- <mvc:resources location="/static/" mapping="/**" /> -->
    <mvc:resources location="file:D:/upload/" mapping="/upload/**" />
</beans>

部署项目

准备资源

在 static 文件夹下创建 js/custom.js 文件，访问静态资源；
在 controller 包下创建 TestController 测试接口；

 
@Controller
@RequestMapping("/test")
public class TestController {
    /**
     * 127.0.0.1/test/desc ---- get
     */
    @GetMapping("/desc")
    @ResponseBody
    public String testDesc() {
        return "This is test module desc.";
    }
}

外置 Tomcat

在 Ide 中修改部署服务器的端口和上下文路径

项目部署到外置容器，参见 Tool_IDE；
访问测试地址

欢迎页面：127.0.0.1/index.jsp
静态资源：127.0.0.1/static/js/custom.js
控制器：127.0.0.1/test/desc

内置 Tomcat

pom.xml 引入 Tomecat jar，为了让项目部署到外置容器中不会造成 jar 冲突，jar 范围为运行时；

1
  <dependency> <groupId>org.apache.tomcat.embed</groupId> <artifactId>tomcat-embed-core</artifactId> <version>${tomcat.version}</version> <scope>provided</scope> </dependency> <dependency> <groupId>org.apache.tomcat.embed</groupId> <artifactId>tomcat-embed-jasper</artifactId> <version>${tomcat.version}</version> <scope>provided</scope> </dependency>
1

2

3
<dependency>
4
<groupId>org.apache.tomcat.embed</groupId>
5
<artifactId>tomcat-embed-core</artifactId>
6
<version>${tomcat.version}</version>
7
<scope>provided</scope>
8
</dependency>
9
<dependency>
10
<groupId>org.apache.tomcat.embed</groupId>
11
<artifactId>tomcat-embed-jasper</artifactId>
12
<version>${tomcat.version}</version>
13
<scope>provided</scope>
14
</dependency>
2

在基础包（com.sfac.springMvc）下添加项目启动类 JavaSpringMvcApplication.java；

public class JavaSpringMvcApplication {

private static int PORT = 80;
    private static String CONTEXT_PATH = "/";

public static void main(String[] args) throws LifecycleException {
//      String baseDir = Thread.currentThread().getContextClassLoader().getResource("").getPath();
        String baseDir = new File("target/classes").getAbsolutePath();
        String appDir = new File("src/main/webapp").getAbsolutePath();
        System.out.println(baseDir);
        System.out.println(appDir);
        
        // 创建 Tomcat，并设置基础目录、端口、连接器
        Tomcat tomcat = new Tomcat();
        tomcat.setBaseDir(baseDir);
        tomcat.setPort(PORT);
        tomcat.getConnector();
        
        // 添加 webapp
        Context context = tomcat.addWebapp(CONTEXT_PATH, appDir);
        WebResourceRoot resources = new StandardRoot(context);
        resources.addPreResources(new DirResourceSet(resources, "/WEB-INF/classes", baseDir, "/"));
        context.setResources(resources);
        
        // 启动服务器
        tomcat.start();
        tomcat.getServer().await();
    }
}

 
public class JavaSpringMvcApplication {
    private static int PORT = 80;
    private static String CONTEXT_PATH = "/";
    public static void main(String[] args) throws LifecycleException {
//      String baseDir = Thread.currentThread().getContextClassLoader().getResource("").getPath();
        String baseDir = new File("target/classes").getAbsolutePath();
        String appDir = new File("src/main/webapp").getAbsolutePath();
        System.out.println(baseDir);
        System.out.println(appDir);
        
        // 创建 Tomcat，并设置基础目录、端口、连接器
        Tomcat tomcat = new Tomcat();
        tomcat.setBaseDir(baseDir);
        tomcat.setPort(PORT);
        tomcat.getConnector();
        
        // 添加 webapp
        Context context = tomcat.addWebapp(CONTEXT_PATH, appDir);
        WebResourceRoot resources = new StandardRoot(context);
        resources.addPreResources(new DirResourceSet(resources, "/WEB-INF/classes", baseDir, "/"));
        context.setResources(resources);
        
        // 启动服务器
        tomcat.start();
        tomcat.getServer().await();
    }
}

Main 方法启动项目，访问以下测试地址；

欢迎页面：127.0.0.1/index.jsp
静态资源：127.0.0.1/static/js/custom.js
控制器：127.0.0.1/test/desc

Idea Main 方法启动失败，做如下配置：

Run/Debug Configurations；
选择 Application - Main（对应自己编写的类名）；
Use classpath of module；
钩上 Include dependencies with "Provided" scope ---- 原因：Pom 依赖中 Tomcat 依赖是 Provided 的，不勾选该项，无法加载相应的包；

基础配置

Log4j 配置

Spring 5 已经废弃了 Log4jConfigListener，所以 Spring 版本不同，引入 Log4j 的方式也不相同，此处以 Spring 5为例子；
pom.xml 引入 jar；

 
<!-- Log4j -->
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-api</artifactId>
    <version>${log4j.version}</version>
</dependency>
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-core</artifactId>
    <version>${log4j.version}</version>
</dependency>
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-web</artifactId>
    <version>${log4j.version}</version>
</dependency>

config 文件夹下加入 log4j.xml 配置；

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="OFF" monitorInterval="1800">

<properties>
		<property name="env">dev</property>
		<property name="project">java_spring_mvc</property>
		<property name="root">/log</property>
		<property name="fileSize">50MB</property>
		<property name="maxHistory">100</property>
		<property name="dateTime">yyyy-MM-dd HH:mm:ss</property>
		<property name="pattern">%d{${dateTime}} [%t] %-5level %logger{36} - %msg%n</property>
	</properties>

<Appenders>
		<Console name="Console" target="SYSTEM_OUT">
			<PatternLayout pattern="${pattern}" />
		</Console>

<Logger name="org.springframework" level="info" additivity="true"> 
			<AppenderRef ref="Console" />
			<AppenderRef ref="running-log" />
		</Logger>

<Root level="debug">
			<AppenderRef ref="Console" />
			<AppenderRef ref="running-log" />
		</Root>
	</Loggers>
</Configuration>

 
<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="OFF" monitorInterval="1800">
    <!-- 配置常量 -->
    <properties>
        <property name="env">dev</property>
        <property name="project">java_spring_mvc</property>
        <property name="root">/log</property>
        <property name="fileSize">50MB</property>
        <property name="maxHistory">100</property>
        <property name="dateTime">yyyy-MM-dd HH:mm:ss</property>
        <property name="pattern">%d{${dateTime}} [%t] %-5level %logger{36} - %msg%n</property>
    </properties>
    <!-- 配置控制台输出和文件输出 -->
    <Appenders>
        <Console name="Console" target="SYSTEM_OUT">
            <PatternLayout pattern="${pattern}" />
        </Console>
        <RollingFile name="running-log"
            fileName="${root}/${project}_${env}.log"
            filePattern="${root}/${project}_${env}_%d.%i.log"
            immediateFlush="true">
            <PatternLayout pattern="${pattern}" />
            <Policies>
                <TimeBasedTriggeringPolicy />
                <SizeBasedTriggeringPolicy size="${fileSize}" />
            </Policies>
            <DefaultRolloverStrategy max="${maxHistory}" />
        </RollingFile>
    </Appenders>
    <Loggers>
        <!-- 指定第三方 jar 或自定义包的输出级别 -->
        <Logger name="org.springframework" level="info" additivity="true"> 
            <AppenderRef ref="Console" />
            <AppenderRef ref="running-log" />
        </Logger>
        <!-- 指定根日志级别TRACE<DEBUG<INFO<WARN<ERROR -->
        <Root level="debug">
            <AppenderRef ref="Console" />
            <AppenderRef ref="running-log" />
        </Root>
    </Loggers>
</Configuration>

web.xml 引入 log4j.xml 并添加 log 监听器和过滤器；

 
<!-- 指定log4j配置文件 -->
<context-param>
    <param-name>log4jConfiguration</param-name>
    <param-value>classpath:config/log4j.xml</param-value>
</context-param>
<!-- Log4j监听器 -->
<listener>
    <listener-class>org.apache.logging.log4j.web.Log4jServletContextListener</listener-class>
</listener>
<!-- Log4j过滤器 -->
<filter>
    <filter-name>log4jServletFilter</filter-name>
    <filter-class>org.apache.logging.log4j.web.Log4jServletFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>log4jServletFilter</filter-name>
    <url-pattern>/*</url-pattern>
    <dispatcher>REQUEST</dispatcher>
    <dispatcher>FORWARD</dispatcher>
    <dispatcher>INCLUDE</dispatcher>
    <dispatcher>ERROR</dispatcher>
</filter-mapping>

在程序中添加 Log 记录；

 
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
/**
 * Description: Test Controller
 * @author HymanHu
 * @date 2020-12-08 10:10:23
 */
@Controller
@RequestMapping("/test")
public class TestController {
    private final static Logger LOGGER = LogManager.getLogger(TestController.class);
    /**
     * 127.0.0.1/test/logger ---- get
     */
    @GetMapping("/logger")
    @ResponseBody
    public String loggerTest() {
        LOGGER.trace("This is trace logger.");
        LOGGER.debug("This is debug logger.");
        LOGGER.info("This is info logger.");
        LOGGER.warn("This is warn logger.");
        LOGGER.error("This is error logger.");
        return "This is logger test.";
    }
}

测试

启动项目，访问接口 127.0.0.1/test/logger，查看控制台和文件输出是否正确；
修改日志级别，重启项目，访问接口查看输出是否正确；

静态资源配置

方式一：<mvc:default-servlet-handler />

Spring 3.0.x 新增 REST 风格，URL 不希望带 .html 或 .do 等后缀，在 web.xml 中配置 DispatcherServlet 的请求映射为 /，Spring MVC 将捕获 Web 容器所有的请求，包括静态资源的请求，但静态资源没有处理器，因此会报错；
该配置会在 Spring MVC 上下文中定义一个 DefaultServletHttpRequestHandler，它会像一个检查员，对进入 DispatcherServlet 的 URL 进行筛查，如果是静态资源的请求，就将该请求转由 Web 服务器默认的 Servlet 处理，如果不是静态资源的请求，才由 DispatcherServlet 继续处理；
一般 Web 服务器默认的 Servlet 名称是 "default"，因此 DefaultServletHttpRequestHandler 可以找到它，如果你所有的 Web 服务器的默认 Servlet 名称不是 "default"，则需要通过 default-servlet-name 属性显示指定；
Tomcat 查看 /conf/web.xml 配置可见；

该配置从项目 webapp 根目录开始计算路径，假设 webapp 下有 static 文件夹放置 css 和 js，那么访问路径类似于：http://127.0.0.1/static/js/custom.js；

方式二：mvc:resources

该配置在处理静态资源上更进一步，由 Spring MVC 框架自己处理静态资源；
<mvc:resources location="/static/" mapping="/**" />
location：没有前缀，从项目 webapp 根目录开始计算路径，访问路径 = 映射路径 + 相对路径，类似于：http://127.0.0.1/static/js/custom.js；
<mvc:resources location="file:D:/upload/" mapping="/upload/**" />
location: 添加 ‘file:’ 前缀，表示用本地文件夹作为静态资源文件夹，访问路径 = 映射路径 + 相对路径，类似于：http://127.0.0.1/upload/test.jpg；

----------------------------------------------------------------
静态资源中文编码问题；

网络标准 RFC 1738 做了硬性规定：URL 只能使用英文字母、阿拉伯数字和某些标点符号，这意味着，如果 URL 中有汉字，就必须编码后使用，但是麻烦的是，RFC 1738 没有规定具体的编码方法，而是交给应用程序（浏览器）自己决定，这导致 URL编码成为了一个混乱的领域；
当静态资源中含有中文：http://127.0.0.1/upload/QQ截图20210219113217.png ---- 经过 URL 编码后变成：http://127.0.0.1/upload/QQ%E6%88%AA%E5%9B%BE20210219113217.png ---- 这样直接在静态资源文件夹内是找不到的；
解决方案：自定义过滤器，如果是静态资源，则使用 utf-8 解码，直接转发到解码后的地址上；

 
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
        throws ServletException, IOException {
    String uri = request.getRequestURI();
    
    if (uri.startsWith("/upload")) {
        request.getRequestDispatcher(URLDecoder.decode(uri, "utf-8")).forward(request, response);
    } else {
        filterChain.doFilter(request, response);
    }
}

配置文件读取

问题：在上一节，我们直接将静态资源路径写在 SpringMvc 配置文件中，如果在 Java 程序中需要用到该路径，不得不再定义一次，还必须保证和 SpringMvc 配置文件中一致，导致代码复用性太差；
解决：将配置内容写在 springMvcParms.properties 中，配置文件导入该属性文件后可直接引用，Java 程序可读取该属性文件形成单独的 ConfigBean，注入可用；
springMvcParms.properties

1
spring.resource.path=/upload/ spring.resource.path.pattern=${spring.resource.path}** spring.resource.folder.windows=d:/upload/springMvc/ spring.resource.folder.linux=/upload/springMvc/
1
spring.resource.path=/upload/
2
spring.resource.path.pattern=${spring.resource.path}**
3
spring.resource.folder.windows=d:/upload/springMvc/
4
spring.resource.folder.linux=/upload/springMvc/
2

springMvcConfig.xml

引入 springMvcParms.properties 是为了直接调用 properties 配置；

 
<!-- 加载属性文件 -->
<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="locations">
       <list>
          <value>classpath:config/properties/springMvcParms.properties</value>
        </list>
    </property>
</bean>
<!-- 处理静态资源方式二
    该配置在处理静态资源上更进一步，由 Spring MVC 框架自己处理静态资源；
    location：没有前缀，从项目 webapp 根目录开始计算路径，
    访问路径 = 映射路径 + 相对路径，类似于：http://127.0.0.1/static/js/custom.js；
    location: 添加 ‘file:’ 前缀，表示用本地文件夹作为静态资源文件夹，
    访问路径 = 映射路径 + 相对路径，类似于：http://127.0.0.1/upload/test.jpg；
-->
<!-- <mvc:resources location="/static/" mapping="/**" /> -->
<!-- <mvc:resources location="file:d:/upload/springMvc/" mapping="/upload/**" /> -->
<mvc:resources location="file:${spring.resource.folder.windows}" mapping="${spring.resource.path.pattern}" />

applicationContext.xml

引入 springMvcParms.properties 是为了在 Java 中读取到配置；

 
<!-- 加载属性文件 -->
<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="locations">
       <list>
          <value>classpath:config/properties/jdbcParms.properties</value>
          <value>classpath:config/properties/hibernateParms.properties</value>
          <value>classpath:config/properties/springMvcParms.properties</value>
        </list>
    </property>
</bean>

ResourceConfigBean.java

 
@Component
@PropertySource("classpath:config/properties/springMvcParms.properties")
public class ResourceConfigBean {
    @Value("${spring.resource.path}")
    private String resourcePath;
    @Value("${spring.resource.path.pattern}")
    private String resourcePathPattern;
    @Value("${spring.resource.folder.windows}")
    private String localPathForWindow;
    @Value("${spring.resource.folder.linux}")
    private String localPathForLinux;
    // 自行添加 get、set方法
}

TestController.java

1
@Autowired private ResourceConfigBean resourceConfigBean; /** * 127.0.0.1/test/config ---- get */ @GetMapping("/config") @ResponseBody public ResourceConfigBean configTest() { return resourceConfigBean; }
1
@Autowired
2
private ResourceConfigBean resourceConfigBean;
3
/**
4
* 127.0.0.1/test/config ---- get
5
*/
6
@GetMapping("/config")
7
@ResponseBody
8
public ResourceConfigBean configTest() {
9
return resourceConfigBean;
10
}
2

三层开发

Vo 对象

Result

 
public class Result<T> {
    private int status;
    private String message;
    private T data;
    public Result() {
    }
    public Result(int status, String message) {
        this.status = status;
        this.message = message;
    }
    public Result(int status, String message, T data) {
        this.status = status;
        this.message = message;
        this.data = data;
    }
    // 自行添加 get、set方法
    /**
     * Description: Result Status
     * @author HymanHu
     * @date 2020-12-09 16:06:12
     */
    public enum ResultStatus {
        SUCCESS(200), FAILED(500);
        public int code;
        private ResultStatus(int code) {
            this.code = code;
        }
    }
}

 
public class Search {
    private int currentPage;
    private int pageSize;
    private String sort;
    private String direction;
    private String keyword;
    public void init() {
        this.currentPage = this.currentPage == 0 ? 1 : this.currentPage;
        this.pageSize = this.pageSize == 0 ? 5 : this.pageSize;
        this.sort = StringUtils.isBlank(this.sort) ? "id" : this.sort;
        this.direction = StringUtils.isBlank(this.direction) ? "ASC" : this.direction;
    }
}

Dao 层开发

命名规则：JavaBeanDao | JavaBeanRepository | JavaBeanMapper，每个JavaBean 对应一个 Dao；
返回值：增删改接口返回 int（影响数据库的条数） OR Void、查询接口返回结果集（JavaBean OR List<JavaBean>）；

Service 层开发

命名规则：JavaBeanService、JavaBeanServiceImpl（实现类放在 impl 子包内），每个 JavaBean 对应一个 Service，中间表对应的 JavaBean 除外；
功能：完成业务处理代码；
返回值：增删改接口返回自定义 ResultEntity 对象、查询接口返回结果集（JavaBean OR List<JavaBean> OR 分页对象）；

Controller 层开发

命名规则：

JavaBeanController，每一个 JavaBean 对应一个“接口控制器”，提供 JavaBean 相关的数据交互；
ModuleController，每个模块对应一个“页面控制器”，专门返回该模块下所有的页面；

功能：匹配请求、接收参数、调用 Service、设置页面参数、返回 View 或者“接口数据”等；
Path 命名规则：RestFul 规则；
控制器参数

Servlet 相关：获取请求、响应对象等；

HttpServletRequest、HttpServletResponse、RedirectAttributes；
InputStream？、OutputStream？ ---- 请求/响应字节流；
Reader？、Writer？；
WebRequest？、NativeWebRequest？；
HttpSession；

Model 相关：暴露控制器中的模型，用于页面的数据渲染；

Map、Model、ModelMap、ExtendedModelMap？；

错误对象：Exception、Error？；
本地对象：Locale？；
请求参数：Path 参数、查询参数、表单参数、Json 参数、文件参数等；

返回值：增删改接口返回 ResponseEntity 对象或自定义 Result 对象，查询操作返回结果集（JavaBean OR List<JavaBean> OR 分页对象）；

时间传递

前端 <----> 控制器；

Json 传递

@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
@JsonSerialize(using = LocalDateTimeSerializer.class) // 序列化
@JsonDeserialize(using = LocalDateTimeDeserializer.class) // 反序列化
反序列化需要添加如下依赖

 
<dependency>
    <groupId>com.fasterxml.jackson.datatype</groupId>
    <artifactId>jackson-datatype-jsr310</artifactId>
</dependency>

Form 表单传递

@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")

Entity <----> DB

Entity：Date、LocalDateTime；
DB：timestamp；

Spring ORM

简介

先来回顾下 Java JDBC 的实现：Java 标准库定义接口，各数据库厂商以“驱动”的形式实现接口，应用程序要使用哪个数据库，就把该数据库厂商的驱动以 jar 包形式引入进来，同时自身仅使用 JDBC 接口，编译期并不需要特定厂商的驱动，JDBC 虽然简单，但代码很繁琐；
Spring 为了简化数据库访问，提供了 JdbcTemplate 和统一的 Dao，但在操作数据时仍然需要手动 Sql、手动填充参数、手动映射查询结果集为 Entity，代码依旧繁琐；
ORM（Object Relational Mapping），即对象关系映射，它的实现思想就是将关系数据库中表的数据映射成为对象，以对象的形式展现，这样开发人员就可以把对数据库的操作转化为对这些对象的操作，方便开发人员以面向对象的思想来实现对数据库的操作；
ORM 框架

Mybatis：在 JdbcTemplate 的基础上，自动填充 JavaBean 参数，自动映射 JavaBean，但仍需要手动写 Sql，被称之为“半自动 ORM”；
Hibernate：自动填充 JavaBean 参数，自动映射 JavaBean，自动解析 JavaBean 为 Hql、Jpql 语句（使用代理技术，框架读取代理类，代理类继承 JavaBean，并对 get、set 方法做了重写，这样代理类可以跟踪到 JavaBean 属性的变化，并封装为 Hql 语句，再转换为 Sql 语句对数据库进行操作），提供缓存（一级缓存（Session 缓存）、二级缓存（跨 Session 缓存）），被称之为“全自动 ORM”；
Jpa：Sun 公司制定的 ORM 规范，自己并没实现，常用的实现框架为 Hibernate；

技术比较

技术	填充参数	映射结果集	查询语句	缓存	特点
JdbcTemplate	手动	手动	手动
Mybatis	自动	自动	手动	一二级缓存
Hibernate	自动	自动	自动	一二级缓存	Hql 转 Sql 多了性能开销； Sql 不够灵活，优化麻烦；缓存增大了数据的不一致性；
Jpa	自动	自动	自动	一二级缓存	引用是 javax.persistence 这个“标准”包，和 org.hibernate 实现包；

Mybatis

简介

半自动 ORM 框架，支持自定义 Sql、存储过程和高级映射，源于 IBatis，2010 年，Apache 的 IBatis 框架停止更新，并移交给了 Google 团队，同时更名为 MyBatis，从 2010 年后 IBatis 再没更新过，彻底变成了一个孤儿框架，一个没人维护的框架注定被 MyBatis 拍在沙滩上；

引入 Jar

在此，我们采用 Mysql 数据库、c3p0 连接池、pagehelper 分页插件，mybatis-generator-core 逆向工程；

<dependency>
	<groupId>mysql</groupId>
	<artifactId>mysql-connector-java</artifactId>
	<version>5.1.48</version>
	
</dependency>

<dependency>
	<groupId>com.mchange</groupId>
	<artifactId>c3p0</artifactId>
	<version>0.9.5.4</version>
</dependency>

<dependency>
	<groupId>org.mybatis</groupId>
	<artifactId>mybatis</artifactId>
	<version>3.4.1</version>
</dependency>
<dependency>
	<groupId>org.mybatis</groupId>
	<artifactId>mybatis-spring</artifactId>
	<version>1.3.1</version>
</dependency>

<dependency>
	<groupId>org.mybatis</groupId>
	<artifactId>mybatis-typehandlers-jsr310</artifactId>
	<version>1.0.2</version>
</dependency>
<dependency>
	<groupId>com.github.pagehelper</groupId>
	<artifactId>pagehelper</artifactId>
	<version>4.1.6</version>
</dependency>

<dependency>
	<groupId>org.mybatis.generator</groupId>
	<artifactId>mybatis-generator-core</artifactId>
	<version>1.3.7</version>
</dependency>

 
<!-- Mysql -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.48</version>
    <!-- <version>8.0.18</version> -->
</dependency>
<!-- 数据库连接池 -->
<dependency>
    <groupId>com.mchange</groupId>
    <artifactId>c3p0</artifactId>
    <version>0.9.5.4</version>
</dependency>
<!-- Mybatis -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.4.1</version>
</dependency>
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>1.3.1</version>
</dependency>
<!-- Mybatis 处理 LocalDatetime -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-typehandlers-jsr310</artifactId>
    <version>1.0.2</version>
</dependency>
<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper</artifactId>
    <version>4.1.6</version>
</dependency>
<!-- mybatis generator -->
<dependency>
    <groupId>org.mybatis.generator</groupId>
    <artifactId>mybatis-generator-core</artifactId>
    <version>1.3.7</version>
</dependency>

配置

配置结构

applicationContext.xml ---- 全局配置，为了避免该文件杂乱，我们按功能拆分为子配置文件；

引入 jdbcParms.properties ---- 数据库、连接池信息；
引入 springMybatis.xml ---- Mybatis 注入 Spring 配置；

引入 mybatisConfig.xml ---- Mybatis 配置，比如：打印 Sql、开启驼峰映射、引入分页插件；

mybatisGeneratorConfig.xml ---- Mybatis 逆向工程配置，单独运行，无需注入全局配置；

applicationContext.xml

 
<!-- 加载属性文件 -->
<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="locations">
       <list>
          <value>classpath:config/properties/jdbcParms.properties</value>
        </list>
    </property>
</bean>
<!-- 引入别的配置文件 -->
<import resource="springMybatis.xml"/>

jdbcParms.properties

1
#jdbc.driverClassName=com.mysql.jdbc.Driver #jdbc.url=jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf8&useSSL=false jdbc.driverClassName=com.mysql.cj.jdbc.Driver jdbc.url=jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=GMT%2B8 jdbc.username=root jdbc.password=root #连接池中连接用完时，c3p0一次性创建的连接数 pool.acquireIncrement=5 #初始化连接数，在minPoolSize和maxPoolSize之间 pool.initialPoolSize=5 pool.minPoolSize=5 pool.maxPoolSize=200 #连接关闭时默认将所有未提交的操作回滚,默认为false pool.autoCommitOnClose=true
1
#jdbc.driverClassName=com.mysql.jdbc.Driver
2
#jdbc.url=jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf8&useSSL=false
3
jdbc.driverClassName=com.mysql.cj.jdbc.Driver
4
jdbc.url=jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=GMT%2B8
5
jdbc.username=root
6
jdbc.password=root
7
8
#连接池中连接用完时，c3p0一次性创建的连接数
9
pool.acquireIncrement=5
10
#初始化连接数，在minPoolSize和maxPoolSize之间
11
pool.initialPoolSize=5
12
pool.minPoolSize=5
13
pool.maxPoolSize=200
14
#连接关闭时默认将所有未提交的操作回滚,默认为false
15
pool.autoCommitOnClose=true
2

mybatisConfig.xml

 
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"   "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <settings>
        <!-- 打印 sql 语句，方式：SLF4J,LOG4J,LOG4J2,JDK_LOGGING,COMMONS_LOGGING,STDOUT_LOGGING,NO_LOGGING -->
        <setting name="logImpl" value="STDOUT_LOGGING" />
        <!-- 开启驼峰映射 -->
        <setting name="mapUnderscoreToCamelCase" value="true" />
    </settings>
    <plugins>
        <!-- 配置分页插件 -->
        <plugin interceptor="com.github.pagehelper.PageHelper">
            <property name="dialect" value="mysql"/>
        </plugin>
    </plugins>
</configuration>

springMybatis.xml

配置链：

datasource ---- sqlSessionFactory ---- sqlSessionTemplate ---- 依次注入，获取 Sql Session 工厂和模版；
datasource ---- sqlSessionFactory ---- mapperScannerConfigurer ---- 依次注入，扫描 Dao 层接口；
datasource ---- transactionManager ---- 依次注入，开启事务；

<?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:tx="http://www.springframework.org/schema/tx" 
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd 
        http://www.springframework.org/schema/tx   
        http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">
        
	
	
	
	<bean id="dataSourceForMybatis" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driverClassName}" />  
        <property name="jdbcUrl" value="${jdbc.url}" />  
        <property name="user" value="${jdbc.username}" />  
        <property name="password" value="${jdbc.password}" /> 
        
        
        <property name="acquireIncrement" value="${pool.acquireIncrement}" />
        
        <property name="initialPoolSize" value="${pool.initialPoolSize}" />
        <property name="minPoolSize" value="${pool.minPoolSize}" />
        <property name="maxPoolSize" value="${pool.maxPoolSize}" />
        
        <property name="autoCommitOnClose" value="${pool.autoCommitOnClose}"/>
    </bean>

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
		
		<property name="dataSource" ref="dataSourceForMybatis"/>
		
		<property name="configLocation" value="classpath:config/mybatisConfig.xml"></property>
		
		<property name="mapperLocations" value="classpath*:mybatis/*.xml" />
	</bean>
	
	
	<bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg name="sqlSessionFactory" ref="sqlSessionFactory"/>
        <constructor-arg name="executorType" value="BATCH"/>
    </bean>
    
    
	<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
		<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
		<property name="basePackage" value="com.sfac.springMvc.module.*.dao" />
	</bean>
	
	
	<bean id="mybatisTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSourceForMybatis"/>
	</bean>
	
	
    <tx:annotation-driven transaction-manager="mybatisTransactionManager" />
</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:tx="http://www.springframework.org/schema/tx" 
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd 
        http://www.springframework.org/schema/tx   
        http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">
        
    <!-- 数据源，spring jdbc || c3p0 jdbc -->
    <!-- <bean id="dataSourceForMybatis" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="${jdbc.driverClassName}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean> -->
    <!-- 配置 c3p0 数据源 -->
    <bean id="dataSourceForMybatis" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driverClassName}" />  
        <property name="jdbcUrl" value="${jdbc.url}" />  
        <property name="user" value="${jdbc.username}" />  
        <property name="password" value="${jdbc.password}" /> 
        
        <!-- 连接池中连接用完时，c3p0 一次性创建的连接数 -->
        <property name="acquireIncrement" value="${pool.acquireIncrement}" />
        <!-- 初始化连接数，在 minPoolSize 和 maxPoolSize 之间 -->
        <property name="initialPoolSize" value="${pool.initialPoolSize}" />
        <property name="minPoolSize" value="${pool.minPoolSize}" />
        <property name="maxPoolSize" value="${pool.maxPoolSize}" />
        <!-- 连接关闭时默认将所有未提交的操作回滚,默认为 false -->
        <property name="autoCommitOnClose" value="${pool.autoCommitOnClose}"/>
    </bean>
    <!-- sqlSessionFactory 单个数据库映射关系经过编译后的内存镜像 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!-- 注入 dataSource -->
        <property name="dataSource" ref="dataSourceForMybatis"/>
        <!-- 扫描 Mybatis 配置文件 -->
        <property name="configLocation" value="classpath:config/mybatisConfig.xml"></property>
        <!-- 扫描 *Mapper.xml 文件 -->
        <property name="mapperLocations" value="classpath*:mybatis/*.xml" />
    </bean>
    
    <!-- 配置一个可以执行批量的 sqlSessionTemplate -->
    <bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg name="sqlSessionFactory" ref="sqlSessionFactory"/>
        <constructor-arg name="executorType" value="BATCH"/>
    </bean>
    
    <!-- 开启自动扫描 dao 接口 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
        <property name="basePackage" value="com.sfac.springMvc.module.*.dao" />
    </bean>
    
    <!-- 配置事务管理器 -->
    <bean id="mybatisTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSourceForMybatis"/>
    </bean>
    
    <!-- 开启事务注解 -->
    <tx:annotation-driven transaction-manager="mybatisTransactionManager" />
</beans>

mybatisGeneratorConfig.xml

需要修改的内容

数据库驱动、地址、用户名、密码；
POJO类、mapper接口、mapper映射文件生成的位置；
指定数据表；

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN" 
"http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
 
<generatorConfiguration>
  <context id="DB2Tables" targetRuntime="MyBatis3">
    <commentGenerator>
    	
    	<property name="suppressAllComments" value="true"/>
    </commentGenerator>
    
    <jdbcConnection driverClass="com.mysql.jdbc.Driver"
        connectionURL="jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&amp;characterEncoding=utf8&amp;useSSL=false"
        userId="root"
        password="root">
    </jdbcConnection>
    
	
	
    <javaTypeResolver >
		<property name="forceBigDecimals" value="false" />
    </javaTypeResolver>
	
	
    <javaModelGenerator targetPackage="com.sfac.springMvc.module.test.entity" targetProject="./src/main/java">
		
		<property name="enableSubPackages" value="false" />
		
		<property name="trimStrings" value="true" />
    </javaModelGenerator>
    
	
    <sqlMapGenerator targetPackage="mybatis"  targetProject="./src/main/resources">
		
		<property name="enableSubPackages" value="false" />
    </sqlMapGenerator>
    
	
	<javaClientGenerator type="XMLMAPPER" targetPackage="com.sfac.springMvc.module.test.dao" 
		targetProject="./src/main/java">
		
		<property name="enableSubPackages" value="false" />
    </javaClientGenerator>
    
	
	<table schema="" tableName="test_city"></table>
	<table schema="" tableName="test_country"></table>
    
    
 
  </context>
</generatorConfiguration>

 
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN" 
"http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
 
<generatorConfiguration>
  <context id="DB2Tables" targetRuntime="MyBatis3">
    <commentGenerator>
        <!-- 是否去除自动生成的注释 -->
        <property name="suppressAllComments" value="true"/>
    </commentGenerator>
    <!-- Mysql数据库连接的信息：驱动类、连接地址、用户名、密码 -->
    <jdbcConnection driverClass="com.mysql.jdbc.Driver"
        connectionURL="jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&amp;characterEncoding=utf8&amp;useSSL=false"
        userId="root"
        password="root">
    </jdbcConnection>
    <!-- Oracle数据库
        <jdbcConnection driverClass="oracle.jdbc.OracleDriver"
            connectionURL="jdbc:oracle:thin:@127.0.0.1:1521:yycg"
            userId="yycg"
            password="yycg">
        </jdbcConnection> 
    -->
    
    <!-- 默认为false，把JDBC DECIMAL 和 NUMERIC 类型解析为 Integer，为 true 时
    把 JDBC DECIMAL 和 NUMERIC 类型解析为java.math.BigDecimal -->
    <javaTypeResolver >
        <property name="forceBigDecimals" value="false" />
    </javaTypeResolver>
    
    <!-- targetProject：生成 POJO 类的位置 -->
    <javaModelGenerator targetPackage="com.sfac.springMvc.module.test.entity" targetProject="./src/main/java">
        <!-- enableSubPackages: 是否让 schema 作为包的后缀 -->
        <property name="enableSubPackages" value="false" />
        <!-- 从数据库返回的值被清理前后的空格 -->
        <property name="trimStrings" value="true" />
    </javaModelGenerator>
    
    <!-- targetProject：mapper 映射文件生成的位置 -->
    <sqlMapGenerator targetPackage="mybatis"  targetProject="./src/main/resources">
        <!-- enableSubPackages:是否让 schema 作为包的后缀 -->
        <property name="enableSubPackages" value="false" />
    </sqlMapGenerator>
    
    <!-- targetProject：mapper 接口生成的的位置 -->
    <javaClientGenerator type="XMLMAPPER" targetPackage="com.sfac.springMvc.module.test.dao" 
        targetProject="./src/main/java">
        <!-- enableSubPackages: 是否让 schema 作为包的后缀 -->
        <property name="enableSubPackages" value="false" />
    </javaClientGenerator>
    
    <!-- 指定数据表 -->
    <table schema="" tableName="test_city"></table>
    <table schema="" tableName="test_country"></table>
    
    <!-- 有些表的字段需要指定java类型 
    <table schema="DB2ADMIN" tableName="ALLTYPES" domainObjectName="Customer" >
      <property name="useActualColumnNames" value="true"/>
      <generatedKey column="ID" sqlStatement="DB2" identity="true" />
      <columnOverride column="DATE_FIELD" property="startDate" />
      <ignoreColumn column="FRED" />
      <columnOverride column="LONG_VARCHAR_FIELD" jdbcType="VARCHAR" />
    </table> -->
 
  </context>
</generatorConfiguration>

应用

Mybatis 逆向工程；

针对“单表”自动生成 Mybatis 执行所需要的代码；
数据库导入 Sql 脚本文件：test.sql，数据库生成两张表，test_country、test_city；
util 包下创建工具类 MybatisGeneratorSqlMap.java；

 
public class MybatisGeneratorSqlMap {
    public void generator() throws Exception {
        List<String> warnings = new ArrayList<String>();
        boolean overwrite = true;
        
        // 指定配置文件
        File configFile = new File(
                MybatisGeneratorSqlMap.class.getResource("/config/mybatisGeneratorConfig.xml").getPath());
        ConfigurationParser cp = new ConfigurationParser(warnings);
        Configuration config = cp.parseConfiguration(configFile);
        DefaultShellCallback callback = new DefaultShellCallback(overwrite);
        MyBatisGenerator myBatisGenerator = new MyBatisGenerator(config, callback, warnings);
        myBatisGenerator.generate(null);
    }
    // 执行main方法以生成代码
    public static void main(String[] args) {
        try {
            MybatisGeneratorSqlMap generatorSqlmap = new MybatisGeneratorSqlMap();
            generatorSqlmap.generator();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行 MybatisGeneratorSqlMap.java；

在配置中指定的位置生成了 JavaBean、Mapper 接口、Mapper Xml 文件，因数据库表名带有 test_前缀，生成的文件也有 Test 前缀，需重构文件名去掉 Test 前缀；
命名规则：数据库（全小写、_连接单词），Java（驼峰法）；
为 JavaBean 时间属性添加格式化：@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")；

Dao 层开发

实现方式一：*Mapper.xml + *Mapper.java 接口；

上面逆向工程已经自动生成了 Mapper Xml 文件和接口；
“接口方法名”和“Xml 文件中 Sql 定义的 id”一一对应；
可按照已有的代码构造自己的 Sql 和接口；

实现方式二：纯接口 + 注解开发，无 *Mapper.xml 文件；

接口注解：@Mapper 注解，相当于 @Repository + @MapperScane；
方法注解：@Select、@Insert、@Update、@Delete、@Options、@Results、@ResultMap 等；
参数注解：@Param；

参数为 JavaBean，Sql 语句中占位符可引用 JavaBean 属性，无需参数注解；
参数为 List，需要添加该注解；
参数不是 JavaBean（非 List），Sql 语句中的占位符和参数名一致并且参数只有一个，无需参数注解，不一致或参数不止一个，则需要参数注解；

Sql 占位符：#{}、${}；

#{*}

相当于 prepared statement：select * from m_city where country_id = ?，防止 Sql 注入；
以 # 的方式，传入的数据被当做字符串，拼接字符串时候自动添加引号，所以在 order by 的时候不能使用 # 的方式；

${*}

相当于 statement：select * from m_city where country_id = 'some id'；

新增接口

需求：插入 City 信息；
CityMapper.java ---- 逆向工程自动生成；
CityDao.java

 
@Repository
@Mapper
public interface CityDao {
    // 要使用 useGeneratedKeys，要求参数必须包含生成的主键，否则抛出异常
    // Error getting generated key or setting result to parameter object
    @Insert("insert into test_city (city_id, city_name, local_city_name, country_id, district, population, "
            + "date_modified, date_created) values (#{cityId}, #{cityName}, #{localCityName}, "
            + "#{countryId}, #{district}, #{population}, #{dateModified}, #{dateCreated})")
    @Options(useGeneratedKeys = true, keyColumn = "city_id", keyProperty = "cityId")
    void insertCity(City city);
}

CityServiceImpl.java

 
@Service
public class CityServiceImpl implements CityService {
    
    @Autowired
    private CityMapper cityMapper;
    @Autowired
    private CityDao cityDao;
    @Override
    @Transactional
    public ResultEntity<City> insertCity(City city) {
        city.setDateCreated(new Date());
        /*
         * -实现方式一：*Mapper.xml + *Mapper.java 接口
         * -如果使用逆向工程生成的 Mapper.xml 文件，无法返回主键值，需要修改 Mapper.xml 中的 insert 方法；
         * <insert id="insert" parameterType="com.sfac.springMvc.entity.City" useGeneratedKeys="true" keyProperty="cityId">
         */
//      cityMapper.insert(city);
        /*
         * -实现方式二：纯接口 + 注解开发
         */
        cityDao.insertCity(city);
        return new ResultEntity<City>(ResultStatus.SUCCESS.status, "Insert city success.", city);
    }
}

CityController.java

 
@RestController
@RequestMapping("/api")
public class CityController {
    
    @Autowired
    private CityService cityService;
    /**
     * 127.0.0.1/api/city ---- post
     * {"cityName":"dreamCity", "localCityName":"梦想城市", "countryId":522, "district":"sichuan", "population":1780000}
     */
    @PostMapping(value = "/city", consumes = "application/json")
    public ResultEntity<City> insertCity(@RequestBody City city) {
        return cityService.insertCity(city);
    }
}

修改接口

需求：根据 cityId 修改 City 信息；
CityDao.java

 
@Update("update test_city set city_name = #{cityName}, local_city_name = #{localCityName}, "
            + "country_id = #{countryId}, district = #{district}, population = #{population}, "
            + "date_modified = #{dateModified} where city_id = #{cityId}")
void updateCity(City city);

CityServiceImpl.java

 
@Override
@Transactional
public ResultEntity<City> updateCity(City city) {
    city.setDateModified(new Date());
    cityDao.updateCity(city);
    int i = 1 / 0;
    return new ResultEntity<City>(ResultStatus.SUCCESS.status, "Update city success.", city);
}

CityController.java

 
/**
 * 127.0.0.1/api/city ---- put
 * cityId=2261,cityName=dreamCity,localCityName=梦想城市1,
 * countryId=522,district=sichuan,population=1780001
 */
@PutMapping(value = "/city", consumes = "application/x-www-form-urlencoded")
public ResultEntity<City> updateCity(@ModelAttribute City city) {
    return cityService.updateCity(city);
}

PostMan 测试，发现控制器接口无法获得 City 属性，原因是 Spring MVC 对 Put 方法支持不好，在 web.xml 中添加如下过滤器解决问题；

1
 <filter> <filter-name>httpMethodFilter</filter-name> <filter-class>org.springframework.web.filter.HttpPutFormContentFilter</filter-class> </filter> <filter-mapping> <filter-name>httpMethodFilter</filter-name> <url-pattern>/*</url-pattern> </filter-mapping>  <filter> <filter-name>hiddenHttpMethodFilter</filter-name> <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class> </filter> <filter-mapping> <filter-name>hiddenHttpMethodFilter</filter-name>  <servlet-name>springMVC</servlet-name> </filter-mapping>
1

2
<filter>
3
<filter-name>httpMethodFilter</filter-name>
4
<filter-class>org.springframework.web.filter.HttpPutFormContentFilter</filter-class>
5
</filter>
6
<filter-mapping>
7
<filter-name>httpMethodFilter</filter-name>
8
<url-pattern>/*</url-pattern>
9
</filter-mapping>
10

11
<filter>
12
<filter-name>hiddenHttpMethodFilter</filter-name>
13
<filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
14
</filter>
15
<filter-mapping>
16
<filter-name>hiddenHttpMethodFilter</filter-name>
17

18
<servlet-name>springMVC</servlet-name>
19
</filter-mapping>
2

删除接口

需求：根据 cityId 删除 City；
CityDao.java

1
@Delete("delete from test_city where city_id = #{cityId}") void deleteCityByCityId(int cityId);
1
@Delete("delete from test_city where city_id = #{cityId}")
2
void deleteCityByCityId(int cityId);
2

CityServiceImpl.java

 
@Override
@Transactional
public ResultEntity<Object> deleteCityByCityId(int cityId) {
    cityDao.deleteCityByCityId(cityId);
    return new ResultEntity<Object>(ResultStatus.SUCCESS.status, "Delete city success.");
}

CityController.java

 
/**
 * 127.0.0.1/api/city/2260 ---- delete
 */
@DeleteMapping("/city/{cityId}")
public ResultEntity<Object> deleteCityByCityId(@PathVariable int cityId) {
    return cityService.deleteCityByCityId(cityId);
}

联表查询接口

需求：根据 cityId 查询 City 信息，包含国家名字；
实现：Sql 语句用 country_id 对 city、country 表做联表查询，可得到 country_name，我们需要在 City.java 中添加 countryName 冗余字段，来接收查询结果；
CityDao.java

 
@Select("select ci.*, co.country_name from test_city ci "
            + "left join country co on ci.country_id = co.country_id "
            + "where ci.city_id = #{cityId}")
City getCityByCityId(int cityId);

CityServiceImpl.java

 
@Override
public City getCityByCityId(int cityId) {
    return cityDao.getCityByCityId(cityId);
}

CityController.java

 
/**
 * 127.0.0.1/api/city/2261 ---- get
 */
@GetMapping("/city/{cityId}")
public City getCityByCityId(@PathVariable int cityId) {
    return cityService.getCityByCityId(cityId);
}

组合查询接口

需求

根据 countryId 查询 Country 信息，但需要返回该国家下所有城市列表；
根据 countryName 查询 Country 信息，但需要返回该国家下所有城市列表；

实现

在 Country.java 中添加 List<City> cities 冗余字段；
CityDao.java 提供 getCitiesByCountryId 接口、CountryDao.java 提供 getCountryByCountryId 接口；
方式一：在 CountryServiceImpl.java 中分别调用两个Dao 层接口，对结果集进行组装；
方式二：在 CountryDao.java 利用组合查询，设置结果集；

CityDao.java

1
@Select("select * from test_city where country_id = #{countryId}") List<City> getCitiesByCountryId(int countryId);
1
@Select("select * from test_city where country_id = #{countryId}")
2
List<City> getCitiesByCountryId(int countryId);
2

CountryDao.java

 
@Repository
@Mapper
public interface CountryDao {
    
    /**
     * @Results ---- 封装结果集，对于联表查询的字段，可调用已有的方法 getCitiesByCountryId
     * column ---- 对应 select 查询后的某个字段名，作为映射实体 bean 属性或者作为调用方法的参数
     * property ---- 对应 实体 bean 属性
     * 1、country_id 封装了两次，分别对应 countryId 和 cities，
     * -而 cities 属性通过 getCitiesByCountryId 方法来实现，country_id作为参数
     * 2、结果集共享，设置 id 属性，调用时使用 @ResultMap(value="countryResults")
     */
    @Select("select * from test_country where country_id = #{countryId}")
    @Results(id = "countryResults", value = {
        @Result(column = "country_id", property = "countryId"),
        @Result(column = "country_id", property = "cities", 
            javaType = List.class,
            many = @Many(select = "com.sfac.springMvc.dao.CityDao.getCitiesByCountryId")
        )
    })
    Country getCountryByCountryId(int countryId);
    
    @Select("select * from test_country where country_name = #{countryName}")
    @ResultMap(value = "countryResults")
    Country getCountryByCountryName(String countryName);
}

CountryServiceImpl.java

 
@Service
public class CountryServiceImpl implements CountryService {
    
    @Autowired
    private CountryDao countryDao;
    @Override
    public Country getCountryByCountryId(int countryId) {
        return countryDao.getCountryByCountryId(countryId);
    }
    
    @Override
    public Country getCountryByCountryName(String countryName) {
        return countryDao.getCountryByCountryName(countryName);
    }
}

CountryController.java

 
@RestController
@RequestMapping("/api")
public class CountryController {
    
    @Autowired
    private CountryService countryService;
    /**
     * 127.0.0.1/api/country/522 ---- get
     */
    @GetMapping("/country/{countryId}")
    public Country getCountryByCountryId(@PathVariable int countryId) {
        return countryService.getCountryByCountryId(countryId);
    }
    
    /**
     * 127.0.0.1/api/country?countryName=China ---- get
     */
    @GetMapping("/country")
    public Country getCountryByCountryName(@RequestParam String countryName) {
        return countryService.getCountryByCountryName(countryName);
    }
}

多条件分页查询接口

需求：按条件（关键字、排序等）对城市列表进行分页查询；
实现

创建 SearchBean.java 对象，用于接收查询参数；
利用 Mybatis 动态 Sql 脚本实现多条件查询，脚本标签：<script>、<where>、<if>、<choose>、<when>、<otherwise>，类似于 Html 标签规则，每个标签有开有合，在标签内构造 Sql 语句；
利用 PageHelper 进行分页；

SearchBean.java

 
public class SearchBean {
    public final static int DEFAULT_CURRENT_PAGE = 1;
    public final static int DEFAULT_PAGE_SIZE = 5;
    
    private int currentPage;
    private int pageSize;
    private String keyWord;
    private String orderBy;
    private String direction;
    // 初始化 search bean
    public void initSearchBean() {
        if (this != null) {
            this.setCurrentPage(this.getCurrentPage() == 0 ? DEFAULT_CURRENT_PAGE : this.getCurrentPage());
            this.setPageSize(this.getPageSize() == 0 ? DEFAULT_PAGE_SIZE : this.getPageSize());
            this.setDirection(StringUtils.isBlank(this.getDirection()) ? "asc" : this.getDirection());
        }
    }
    // 自行添加 get、set 方法
}

CityDao.java

注意

test='' 语句，等号两端带空格导致判断失效，出现过该情况，未找到合理解释！
不支持 < > 符号，书写时候需要转义：" and (grade < 3 ) || <="

 
@Select("<script>"
        + "select ci.*, co.country_name from test_city ci left join country co "
        + "on ci.country_id = co.country_id "
        + "<where> "
        + "<if test='keyWord != \"\" and keyWord != null'>"
        + " and (ci.city_name like '%${keyWord}%' "
        + "or ci.local_city_name like '%${keyWord}%' "
        + "or co.country_name like '%${keyWord}%') "
        + "</if>"
        + "</where>"
        + "<choose>"
        + "<when test='orderBy != \"\" and orderBy != null'>"
        + " order by ${orderBy} ${direction}"
        + "</when>"
        + "<otherwise>"
        + " order by city_id desc"
        + "</otherwise>"
        + "</choose>"
        + "</script>")
List<City> getCitiesBySearchBean(SearchBean searchBean);

 
@Select("<script>"
        + "select * from common_video "
        + "<where> "
        + " and (grade &lt;= #{grade} ) "
        + "<if test='type != \"\" and type != null'>"
        + " and (type = #{type}) "
        + "</if>"
        + "<if test='search.keyword != \"\" and search.keyword != null'>"
        + " and (name like '%${search.keyword}%' or subject like '%${search.keyword}%' or "
        + " number like '%${search.keyword}%' or star like '%${search.keyword}%' or imdb like '%${search.keyword}%') "
        + "</if>"
        + "</where>"
        + "<choose>"
        + "<when test='search.sort != \"\" and search.sort != null'>"
        + " order by ${search.sort} ${search.direction}"
        + "</when>"
        + "<otherwise>"
        + " order by id desc"
        + "</otherwise>"
        + "</choose>"
        + "</script>")
List<Video> getVideosBySearchAndTypeAndGrade(
        @Param("search") Search search, 
        @Param("grade") int grade, 
        @Param("type") String type);

CityServiceImpl.java

 
@Override
public PageInfo<City> getCitiesBySearchBean(SearchBean searchBean) {
    searchBean.initSearchBean();
    PageHelper.startPage(searchBean.getCurrentPage(), searchBean.getPageSize());
    return new PageInfo<City>(Optional.ofNullable(cityDao.getCitiesBySearchBean(searchBean))
            .orElse(Collections.emptyList()));
}

CityController.java

 
/**
 * 127.0.0.1/api/cities ---- post
 * {"currentPage":1, "pageSize":5, "keyWord":"china", "orderBy":"ci.city_id", "direction":"desc"}
 */
@PostMapping(value = "/cities", consumes = "application/json")
public PageInfo<City> getCitiesBySearchBean(@RequestBody SearchBean searchBean) {
    return cityService.getCitiesBySearchBean(searchBean);
}

批量新增接口

需求：批量插入城市信息；
实现：利用 Mybatis Sql 脚本构造批量插入语句；
CityDao.java

 
@Insert("<script>"
        + "insert into test_city (city_id, city_name, local_city_name, country_id, district, "
        + "population, date_modified, date_created) values "
        + "<foreach collection='cities' item='city' index='index' separator=','>"
        + "(#{city.cityId}, #{city.cityName}, #{city.localCityName}, #{city.countryId}, "
        + "#{city.district}, #{city.population}, #{city.dateModified}, #{city.dateCreated})"
        + "</foreach>"
        + "</script>")
@Options(useGeneratedKeys = true, keyColumn = "city_id", keyProperty = "cityId")
void batchInsertCities(@Param("cities") List<City> cities);

CityServiceImpl.java

 
@Override
@Transactional
public ResultEntity<List<City>> batchInsertCities(List<City> cities) {
    cities.forEach(item -> {
        item.setDateCreated(new Date());
    });
    cityDao.batchInsertCities(cities);
    return new ResultEntity<List<City>>(ResultStatus.SUCCESS.status, "Insert city success.", cities);
}

CityController.java

 
/**
 * 127.0.0.1/api/cities/v2 ---- post
 * [{"cityName":"dreamCity1", "localCityName":"梦想城市1", "countryId":522, "district":"sichuan", 
 * "population":1780000},{"cityName":"dreamCity2", "localCityName":"梦想城市2", "countryId":522, 
 * "district":"sichuan", "population":1780000}]
 */
@PostMapping(value = "/cities/v2", consumes = "application/json")
public ResultEntity<List<City>> batchInsertCities(@RequestBody List<City> cities) {
    return cityService.batchInsertCities(cities);
}

批量插入数据过大，导致数据库异常：Packet for query is too large (4317197 > 1048576). You can change this value on the server by setting the max_allowed_packet' variable.

查询：show VARIABLES like '%max_allowed_packet%';
修改此变量的值：SET GLOBAL max_allowed_packet=16*1024*1024; 或修改 my.ini 中 max_allowed_packet 值；
重起MySQL服务；
--------
不建议调整 Mysql max_allowed_packet 参数，使用 BATCH 的方式插入 ---- 参照高德地图接口 /api/region/init；

缓存

让应用程序减少对数据库的访问，提升程序运行效率；
一级缓存 SqlSession

MyBatis 中默认开启 SqlSession 缓存；
缓存区查找是否存在 statement（对应 <select>）；
有则返回结果；
无则去数据库查询并返回结果；
将 statement 缓存到 SqlSession 缓存区（内存）中；

二级缓存 SqlSessionFactory

有效范围：同一个 factory 内所有 SqlSession 都可以获取；
数据频繁被使用并很少被修改时，使用二级缓存；
默认情况下，Mybatis 打开了二级缓存，但它并未生效，因为二级缓存的作用域是 namespace，所以还需要在 Mapper.xml 文件中配置一下才能使二级缓存生效；
<cache readOnly=“true”></cache> ---- 如果不配置 readOnly，那么实体需要序列化；

PageHelper 分页查询原理

PageHelper.startPage(search.getCurrentPage(), search.getPageSize());

构造了 Page 对象，该对象继承 ArrayList 类，额外封装了 count、pageNum、pageSize 等属性；
将 Page 对象存入 ThreadLocal 中，维护线程副本数据，实现线程数据隔离；

return new PageInfo<User>(Optional.ofNullable(userDao.getUsersBySearch(search)).orElse(Collections.emptyList()));

构造器中执行 userDao.getUsersBySearch(search)，调用 Executor 接口；
PageInterceptor：该拦截器拦截 Executor 接口 query 方法，当执行 userDao.getUsersBySearch(search) 时，将其 sql 拆分成两个 sql，一个加 limit 进行分页查询，一个查询总数；
PageParams：该类从 ThreadLocal 中获取 Page 对象，并将拦截器查询结果设置到 Page 对象中；

如果直接调用 userDao.getUsersBySearch(search) 拦截器无法拦截该 Dao 层接口，无法实现分页；

Hibernate

简介

Hibernate 是一个开放源代码的对象关系映射框架，它对 JDBC 进行了非常轻量级的对象封装，它将 POJO 与数据库表建立映射关系，是一个全自动的 ORM 框架，使得 Java 程序员可以随心所欲的使用对象编程思维来操纵数据库；
Hibernate 的核心 API：Session、SessionFactory、Transaction、Query、Criteria 和 Configuration，通过这些接口，可以对持久化对象进行存取、事务控制；
查询语言

HQL 语言

Hibernate 造出来的对象语言，只有 Hibernate 框架能够解析，并将其通过一系列的映射转换，拼凑成 SQL 语言；
使用 “类名” 取代 “表名”，用 “类名.属性名” 取代 “表名.列名”，类名建议不要省略；
没有 * 查询，以 from 类名表示；

主键类型

Assigned：由用户生成主键值，并且要在 save() 之前指定否则会抛出异常；
Hilo：使用高低位算法生成主键；
Increment：采取自动增长的方式生成新的主键值，但要求底层数据库的主键类型为 long、int 等数值型，主键按数值顺序递增，增量为 1，不能用于群集环境；
Identity：根据底层数据库，来支持自动增长，不同的数据库用不同的主键增长方式；
Sequence：需要底层数据库支持 Sequence 方式，例如 Oracle 数据库；
Native：根据不同的底层数据库自动选择 Identity、Sequence、Hilo 主键生成方式；
UUID：使用 128 位 UUID 算法生成主键，能够保证网络环境下的主键唯一性，也就能够保证在不同数据库及不同服务器下主键的唯一性，但生成的主键占用比较多的存贮空间；
Foreign GUID：使用了一种特殊算法，用于一对一关系中，保证生成主键的唯一性，支持 SQL Server 和 MySQL；

缓存管理

一级缓存

又叫 Session 缓存，属于事务范畴的缓存；
当应用程序调用 Session 的 save()、update()、saveOrUpdate()、get() 或 load() 等方法时，如果在 Session 缓存中还不存在相应的对象，Hibernate 就会把该对象加入到第一级缓存中；
调用查询接口，直接从缓存中获取数据；
调用增删改接口，修改数据库的同时，更新缓存数据；

二级缓存

又叫跨事务缓存，属于进程范围或集群范围的缓存；
条件查询的时候，总是发出一条 select * from table_name where …. 这样的 SQL 语句查询数据库，一次获得所有的数据对象；
把获得的所有数据对象根据 ID 放入到第二级缓存中；
当 Hibernate 根据 ID 访问数据对象的时候，首先从 Session 一级缓存中查，如果查不到且配置了二级缓存，那么从二级缓存中查，二级缓存还查不到，再查询数据库，把结果一二级缓存中；
删除、更新、增加数据的时候，同时更新缓存；

加载策略

延迟加载：在读取一个对象的时候，只读对象本身，当该对象调用它的一对多或多对多关系时才将关联对象读取出来；
非延迟加载：在读取一个对象的时候，会将与这个对象所有相关的其他对象一起读取出来，这有时会导致多条 Select 语句执行；

引入 Jar

 
<!-- Hibernate -->
<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-core</artifactId>
    <version>5.4.25.Final</version>
</dependency>

配置

配置结构

applicationContext.xml ---- 全局配置，为了避免该文件杂乱，我们按功能拆分为子配置文件；

引入 jdbcParms.properties ---- Jdbc 配置信息；
引入 hibernateParms.properties ---- Hibernate 配置属性信息；
引入 springHibernate.xml ---- Hibernate 注入 Spring 配置；

applicationContext.xml

 
<!-- 加载属性文件 -->
<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="locations">
       <list>
          <value>classpath:config/properties/jdbcParms.properties</value>
          <value>classpath:config/properties/hibernateParms.properties</value>
        </list>
    </property>
</bean>
<!-- 引入别的配置文件 -->
<import resource="springHibernate.xml"/>

hibernateParms.properties

1
hibernate.hbm2ddl.auto=update hibernate.implicit_naming_strategy=com.sfac.springMvc.config.HibernateNamingStrategy hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect hibernate.show_sql=true hibernate.format_sql=true hibernate.connection.autocommit=true
1
hibernate.hbm2ddl.auto=update
2
hibernate.implicit_naming_strategy=com.sfac.springMvc.config.HibernateNamingStrategy
3
hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect
4
hibernate.show_sql=true
5
hibernate.format_sql=true
6
hibernate.connection.autocommit=true
2

springHibernate.xml

配置链

dataSource ---- sessionFactory ---- hibernateTemplate；
dataSource ---- sessionFactory ---- transactionManager；
---------------------------------------------------------------
Hibernate 源生 Session 接口（从 SessionFactory 获取），而 HibernateTemplate 是 Spring 提供的 Hibernate 工具类，相当于封装好的 Dao 层，不是非用不可，但推荐使用以简化代码；

注意：引入的 spring-orm 版本不同，sessionFactory 等 Bean 的包路径不同：hibernate4 -> hibernate5；

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" 
       xmlns:context="http://www.springframework.org/schema/context" 
       xmlns:aop="http://www.springframework.org/schema/aop" 
       xmlns:tx="http://www.springframework.org/schema/tx" 
       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-3.0.xsd 
		http://www.springframework.org/schema/context 
		http://www.springframework.org/schema/context/spring-context-3.0.xsd 
		http://www.springframework.org/schema/mvc 
		http://www.springframework.org/schema/mvc/spring-mvc-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">
		
	
	
	
	<bean id="dataSourceForHibernate" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driverClassName}" />  
        <property name="jdbcUrl" value="${jdbc.url}" />  
        <property name="user" value="${jdbc.username}" />  
        <property name="password" value="${jdbc.password}" /> 
        
        
        <property name="acquireIncrement" value="${pool.acquireIncrement}" />
        
        <property name="initialPoolSize" value="${pool.initialPoolSize}" />
        <property name="minPoolSize" value="${pool.minPoolSize}" />
        <property name="maxPoolSize" value="${pool.maxPoolSize}" />
        
        <property name="autoCommitOnClose" value="${pool.autoCommitOnClose}"/>
    </bean>
		
	<bean id="sessionFactory"
        class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSourceForHibernate" />
        
        <property name="packagesToScan">
        	<list>
        		<value>com.sfac.springMvc.module.*.entity</value>
        	</list>
        </property>
        
        <property name="implicitNamingStrategy">
        	
        	<bean class="com.sfac.springMvc.config.HibernateNamingStrategy"></bean>
		</property>
		<property name="hibernateProperties">
			<props>
				
				<prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>
				
				<prop key="hibernate.dialect">${hibernate.dialect}</prop>
				<prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
				<prop key="hibernate.format_sql">${hibernate.format_sql}</prop>
			</props>
		</property>
	</bean>
	
    
    <bean id="hibernateTemplate" class="org.springframework.orm.hibernate5.HibernateTemplate">
        <property name="sessionFactory" ref="sessionFactory" />
        <property name="checkWriteOperations" value="false"></property>
    </bean>
    
    
    <bean id="hibernateTransactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>
    
    
    <tx:annotation-driven transaction-manager="hibernateTransactionManager"/>
</beans>

 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" 
       xmlns:context="http://www.springframework.org/schema/context" 
       xmlns:aop="http://www.springframework.org/schema/aop" 
       xmlns:tx="http://www.springframework.org/schema/tx" 
       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-3.0.xsd 
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context-3.0.xsd 
        http://www.springframework.org/schema/mvc 
        http://www.springframework.org/schema/mvc/spring-mvc-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">
        
    <!-- 数据源，spring jdbc || c3p0 jdbc -->
    <!-- <bean id="dataSourceForHibernate" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="${jdbc.driverClassName}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean> -->
    <!-- 配置 c3p0 数据源 -->
    <bean id="dataSourceForHibernate" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driverClassName}" />  
        <property name="jdbcUrl" value="${jdbc.url}" />  
        <property name="user" value="${jdbc.username}" />  
        <property name="password" value="${jdbc.password}" /> 
        
        <!-- 连接池中连接用完时，c3p0 一次性创建的连接数 -->
        <property name="acquireIncrement" value="${pool.acquireIncrement}" />
        <!-- 初始化连接数，在 minPoolSize 和 maxPoolSize 之间 -->
        <property name="initialPoolSize" value="${pool.initialPoolSize}" />
        <property name="minPoolSize" value="${pool.minPoolSize}" />
        <property name="maxPoolSize" value="${pool.maxPoolSize}" />
        <!-- 连接关闭时默认将所有未提交的操作回滚,默认为 false -->
        <property name="autoCommitOnClose" value="${pool.autoCommitOnClose}"/>
    </bean>
        
    <bean id="sessionFactory"
        class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSourceForHibernate" />
        <!-- 扫描 Entity 包 -->
        <property name="packagesToScan">
            <list>
                <value>com.sfac.springMvc.module.*.entity</value>
            </list>
        </property>
        <!-- 命名规则隐式策略 -->
        <property name="implicitNamingStrategy">
            <!-- 采用自定义配置 -->
            <bean class="com.sfac.springMvc.config.HibernateNamingStrategy"></bean>
        </property>
        <property name="hibernateProperties">
            <props>
                <!-- 动态生成表策略 -->
                <prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>
                <!-- 数据库方言 -->
                <prop key="hibernate.dialect">${hibernate.dialect}</prop>
                <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
                <prop key="hibernate.format_sql">${hibernate.format_sql}</prop>
            </props>
        </property>
    </bean>
    
    <!-- 引入hibernateTemplate -->
    <bean id="hibernateTemplate" class="org.springframework.orm.hibernate5.HibernateTemplate">
        <property name="sessionFactory" ref="sessionFactory" />
        <property name="checkWriteOperations" value="false"></property>
    </bean>
    
    <!-- 配置事务管理器 -->
    <bean id="hibernateTransactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>
    
    <!-- 开启事务注解 -->
    <tx:annotation-driven transaction-manager="hibernateTransactionManager"/>
</beans>

应用

相关注解

@MappedSuperclass ---- 标识基类（父类），不能有 @Entity 和 @Table，子类会自动映射父类属性；
@Entity ---- 必选的注解，声明这个类对应了一个数据库表；
@Table(name = "user") ---- 可选的注解，声明了实体对应的表信息，包括表名称、索引等，如果没有指定，则表名和实体的名称保持一致；
@Id ---- 声明实体唯一标识对应的属性；
@GeneratedValue(strategy = GenerationType.IDENTITY) ---- Jpa 通用策略主键生成策略；

TABLE：使用一个特定的数据库表格来保存主键；
SEQUENCE：其提供了一种叫做“序列（sequence）”的机制生成主键，在某些数据库中不支持主键自增长，比如 Oracle；
IDENTITY：主键由数据库以自增的方式自动生成；
AUTO：主键由程序控制；

@GenericGenerator ---- 自定义主键生成策略；

@GeneratedValue(generator="system-uuid")
@GenericGenerator(name="system-uuid", strategy = "uuid.hex") ---- 用 Hibernate 的 uuid 主键生成器；

@Column(name = "card_no", length = 33, unique = true, columnDefinition="varchar(128) not null") ---- 声明实体 Bean 属性对应列，默认每个属性都对应了表的一列，列名默认驼峰转下划线，列的类型根据实体属性类型自动推断，默认长度 255，也可自定义列类型；
@Transient ---- 声明该属性不参与和数据库的映射；
@PrePersist ---- 声明该方法在 Hibernate Insert Bean 之前调用，例如设置 createDate 属性；
@CreatedDate | @LastModifiedDate ---- 创建时间和最后更新时间，需要在类上添加 @EntityListeners(AuditingEntityListener.class) 注解，并在 Spring Boot 启动类上添加 @EnableJpaAuditing 注解；
CascadeType ---- 级联操作，操作当前 Bean 时，设置操作关联 Bean 的权限；

CascadeType.REMOVE ---- 删除当前 Bean 时，与它有映射关系的 Bean 也会跟着被删除；
CascadeType.MERGE ---- 变更当前 Bean 时，更新与之映射的 Bean；
CascadeType.DETACH ---- 如果你要删除一个 Bean，但是它有外键无法删除，你就需要这个级联权限了，它会撤销所有相关的外键关联；
CascadeType.REFRESH ---- 级联刷新操作，比如：有一个订单，订单里面关联了许多商品，这个订单可以被很多人操作，那么这个时候 A 对此订单和关联的商品进行了修改，与此同时，B 也进行了相同的操作，但是 B 先一步比 A 保存了数据，那么当 A 保存数据的时候，就需要先刷新订单信息及关联的商品信息后，再将订单及商品保存；
CascadeType.ALL ---- 拥有以上所有级联操作权限；

FetchType ---- 数据加载策略；

FetchType.LAZY ---- 懒加载，加载一个 Bean 时，定义懒加载的属性不会马上从数据库中加载；
FetchType.EAGER ---- 急加载，加载一个 Bean 时，定义急加载的属性会立即从数据库中加载；

@OneToOne，@OneToMany，@ManyToMany，@ManyToOne

一对一关系中，有外键方使用 JoinColumn 注解，另一方使用 mappedBy 属性；
一对多关系中，多方使用 JoinColumn 注解，会产生外键，一方使用 mappedBy 属性；
多对多关系中，一方使用 JoinTable 注解，标识中间表，并标明两个关联表的主键，另一方使用 mappedBy 属性；

@persistencecontext

该注解是一个用来操作实例化对象与进行数据持久化的一个注解，它实际上是在内存中保存了一些实体类对象实例所构成的一些集合，它能够根据实体类状态的变化，完成持久化操作，该注解与 EntityManager 一起使用；

自动生成表

在 modules\test\entity 下创建实体 Bean，自行添加 get、set 方法；

@MappedSuperclass
public class AbstractEntity {
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	@Column(nullable = false, updatable = false)
	private Integer id;
	@JsonSerialize(using = LocalDateTimeSerializer.class)
	@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
	@Column(updatable = false)
	private LocalDateTime createDate;
	
	// 在 insert 之前，该方法被调用
	@PrePersist
	public void preInsert() {
		setCreateDate(LocalDateTime.now());
	}
}
@Entity
@Table(name = "test_student")
public class Student extends AbstractEntity {
	private String studentName;
	
	/**
	 * OneToOne：一对一关系中，有外键方使用 JoinColumn 注解，另一方使用 mappedBy 属性（可选）
	 * targetEntity：目标实体
	 * cascade：联级操作
	 * fetch：加载数据策略
	 * JoinColumn
	 * name 对应 test_student 表中 card_id 外键列
	*/
	@OneToOne(targetEntity = Card.class, cascade = CascadeType.ALL, fetch = FetchType.EAGER)
	@JoinColumn(name = "card_id", unique = true)
	private Card studentCard;
    
	/**
	 * ManyToMany，一方使用 JoinTable 注解，另一方配置 mappedBy 属性
	 * cascade：联级操作
	 * fetch：加载数据策略
	 * JsonIgnore：不序列化该字段，避免无限递归
	*/
	@ManyToMany(mappedBy = "students", cascade = CascadeType.ALL, fetch = FetchType.EAGER)
	@JsonIgnore
	private List<Clazz> clazzes;
}
@Entity
@Table(name = "test_card")
public class Card extends AbstractEntity {
	@Column(name = "card_no", length = 33, unique = true)
	private String cardNo;
	
	/**
	 * OneToOne：一对一关系中，有外键方使用 JoinColumn 注解，另一方使用 mappedBy 属性（可选）
	 * cascade：联级操作
	 * fetch：加载数据策略
	 * JsonIgnore：不序列化该字段，避免无限递归
	*/
	@OneToOne(mappedBy = "studentCard", cascade = CascadeType.ALL, fetch = FetchType.EAGER)
	@JsonIgnore
	private Student student;
}
@Entity
@Table(name = "test_clazz")
public class Clazz extends AbstractEntity {
	private String clazzName;
    
	/**
	 * ManyToMany，一方使用 JoinTable 注解，另一方配置 mappedBy 属性
	 * cascade：联级操作
	 * fetch：加载数据策略
	 * JoinTable：中间表
	 * name： 中间表表名
	 * joinColumns：表 test_clazz 参与中间表的主键
	 * inverseJoinColumns：关联表 test_student 参与中间表的主键
	*/
	@ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
	@JoinTable(name = "test_clazz_student",
		joinColumns = @JoinColumn(name = "clazz_id"),
		inverseJoinColumns = @JoinColumn(name="student_id"))
	private List<Student> students;
	
	/**
	 * ManyToOne：多方使用 joinClumn，创建外键，一方使用 mappedBy 属性
	 * cascade：联级操作
	 * fetch：加载数据策略
	 * JoinColumn
	 * name：多方 test_clazz 表的外键 school_id
	 * insertable & updatable：标识该属性是否参与插入和更新插入
	 * JsonIgnore：不序列化该字段，避免无限递归
	*/
	@ManyToOne(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
	@JoinColumn(name = "school_id", insertable = false, updatable = false)
	@JsonIgnore
	private School school;
}
@Entity
@Table(name = "test_school")
public class School extends AbstractEntity {
	private String schoolName;
    // 定义数据库 text 类型，存储 64 KB 数据
    @Column(columnDefinition="text")
    private String description;
	@Transient
	private String region;
    
	/**
	 * OneToMany：多方使用 joinClumn，创建外键，一方使用 mappedBy 属性
	 * cascade：联级操作
	 * fetch：加载数据策略
	*/
	@OneToMany(mappedBy = "school", cascade = CascadeType.ALL, fetch = FetchType.EAGER)
	private List<Clazz> clazzes;
}

 
@MappedSuperclass
public class AbstractEntity {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(nullable = false, updatable = false)
    private Integer id;
    @JsonSerialize(using = LocalDateTimeSerializer.class)
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
    @Column(updatable = false)
    private LocalDateTime createDate;
    
    // 在 insert 之前，该方法被调用
    @PrePersist
    public void preInsert() {
        setCreateDate(LocalDateTime.now());
    }
}
@Entity
@Table(name = "test_student")
public class Student extends AbstractEntity {
    private String studentName;
    
    /**
     * OneToOne：一对一关系中，有外键方使用 JoinColumn 注解，另一方使用 mappedBy 属性（可选）
     * targetEntity：目标实体
     * cascade：联级操作
     * fetch：加载数据策略
     * JoinColumn
     * name 对应 test_student 表中 card_id 外键列
    */
    @OneToOne(targetEntity = Card.class, cascade = CascadeType.ALL, fetch = FetchType.EAGER)
    @JoinColumn(name = "card_id", unique = true)
    private Card studentCard;
    
    /**
     * ManyToMany，一方使用 JoinTable 注解，另一方配置 mappedBy 属性
     * cascade：联级操作
     * fetch：加载数据策略
     * JsonIgnore：不序列化该字段，避免无限递归
    */
    @ManyToMany(mappedBy = "students", cascade = CascadeType.ALL, fetch = FetchType.EAGER)
    @JsonIgnore
    private List<Clazz> clazzes;
}
@Entity
@Table(name = "test_card")
public class Card extends AbstractEntity {
    @Column(name = "card_no", length = 33, unique = true)
    private String cardNo;
    
    /**
     * OneToOne：一对一关系中，有外键方使用 JoinColumn 注解，另一方使用 mappedBy 属性（可选）
     * cascade：联级操作
     * fetch：加载数据策略
     * JsonIgnore：不序列化该字段，避免无限递归
    */
    @OneToOne(mappedBy = "studentCard", cascade = CascadeType.ALL, fetch = FetchType.EAGER)
    @JsonIgnore
    private Student student;
}
@Entity
@Table(name = "test_clazz")
public class Clazz extends AbstractEntity {
    private String clazzName;
    
    /**
     * ManyToMany，一方使用 JoinTable 注解，另一方配置 mappedBy 属性
     * cascade：联级操作
     * fetch：加载数据策略
     * JoinTable：中间表
     * name： 中间表表名
     * joinColumns：表 test_clazz 参与中间表的主键
     * inverseJoinColumns：关联表 test_student 参与中间表的主键
    */
    @ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
    @JoinTable(name = "test_clazz_student",
        joinColumns = @JoinColumn(name = "clazz_id"),
        inverseJoinColumns = @JoinColumn(name="student_id"))
    private List<Student> students;
    
    /**
     * ManyToOne：多方使用 joinClumn，创建外键，一方使用 mappedBy 属性
     * cascade：联级操作
     * fetch：加载数据策略
     * JoinColumn
     * name：多方 test_clazz 表的外键 school_id
     * insertable & updatable：标识该属性是否参与插入和更新插入
     * JsonIgnore：不序列化该字段，避免无限递归
    */
    @ManyToOne(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
    @JoinColumn(name = "school_id", insertable = false, updatable = false)
    @JsonIgnore
    private School school;
}
@Entity
@Table(name = "test_school")
public class School extends AbstractEntity {
    private String schoolName;
    // 定义数据库 text 类型，存储 64 KB 数据
    @Column(columnDefinition="text")
    private String description;
    @Transient
    private String region;
    
    /**
     * OneToMany：多方使用 joinClumn，创建外键，一方使用 mappedBy 属性
     * cascade：联级操作
     * fetch：加载数据策略
    */
    @OneToMany(mappedBy = "school", cascade = CascadeType.ALL, fetch = FetchType.EAGER)
    private List<Clazz> clazzes;
}

使用 Hibernate 时，属性最好不要使用基本类型，而要使用包装类型，因为在使用 findByExample() 操作时，基本类型字段总是会加入到 WHERE 条件，需要我们手动排除掉；
启动项目，数据库会自动生成对应的表结构；
实体 Bean 的属性和数据库表字段在“顺序”上不一致，重写 PropertyContainer，将 TreeMap 变成 LinkedHashMap；

新增接口

我们在配置文件中注入了 HibernateTemplate，是 Spring 提供的操作 Hibernate 工具类，可以在 Service 层直接调用；
StudentServiceImpl.java

 
@Service
public class StudentServiceImpl implements StudentService {
    
    @Autowired
    private HibernateTemplate hibernateTemplate;
    @Override
    @Transactional("hibernateTransactionManager")
    public ResultEntity<Student> insertStudentForHibernate(Student student) {
        hibernateTemplate.saveOrUpdate(student);
        return new ResultEntity<Student>(ResultStatus.SUCCESS.status, "Insert success.", student);
    }
}

StudentController.java

 
@RestController
@RequestMapping("/api")
public class StudentController {
    @Autowired
    private StudentService studentService;
    
    /**
     * 127.0.0.1/api/hibernate/student ---- post
     * {"studentName":"HymanHu"}
     * {"studentName":"HymanHu", "studentCard":{"cardNo":"studentCard001"}}
     */
    @PostMapping(value = "/hibernate/student", consumes = "application/json")
    public ResultEntity<Student> insertStudentForHibernate(@RequestBody Student student) {
        return studentService.insertStudentForHibernate(student);
    }
}

修改接口

StudentServiceImpl.java

 
// 系统中配置又多个事务管理器，所以需要在调用的时候需要指明
@Override
@Transactional("hibernateTransactionManager")
public ResultEntity<Student> updateStudentForHibernate(Student student) {
    hibernateTemplate.saveOrUpdate(student);
//  int i = 1 / 0;
    return new ResultEntity<Student>(ResultStatus.SUCCESS.status, "Update success.", student);
}

StudentController.java

 
/**
 * 127.0.0.1/api/hibernate/student ---- put
 * {"id":"2","studentName":"HymanHu1"}
 * {"id":"2","studentName":"HymanHu1","studentCard":{"id":"1","cardNo":"studentCard002"}}
 */
@PutMapping(value = "/hibernate/student", consumes = "application/json")
public ResultEntity<Student> updateStudentForHibernate(@RequestBody Student student) {
    return studentService.updateStudentForHibernate(student);
}

删除接口

StudentServiceImpl.java

 
@Override
@Transactional("hibernateTransactionManager")
public ResultEntity<Object> deleteStudentForHibernate(Integer id) {
    Student student = new Student();
    student.setId(id);
    hibernateTemplate.delete(student);
    return new ResultEntity<Object>(ResultStatus.SUCCESS.status, "Delete success.");
}

StudentController.java

 
/**
 * 127.0.0.1/api/hibernate/student/2 ---- delete
 */
@DeleteMapping("/hibernate/student/{id}")
public ResultEntity<Object> deleteStudentForHibernate(@PathVariable Integer id) {
    return studentService.deleteStudentForHibernate(id);
}

查询接口

StudentServiceImpl.java

@Override
public Student getStudentByIdForHibernate(Integer id) {
	return hibernateTemplate.get(Student.class, id);
}

@SuppressWarnings({ "unchecked", "deprecation" })
@Override
public Student getStudentByNameForHibernate(String studentName) {
	// Example 查询
	Student example = new Student();
	example.setStudentName(studentName);
	List<Student> students = hibernateTemplate.findByExample(example);
	// Hql 查询
	students = (List<Student>) hibernateTemplate.find("from Student where studentName like ?0", 
			String.format("%%%s%%", studentName));
	return students.isEmpty() ? null : students.get(0);
}

/**
 * criteria 多条件查询，示例 sql
 * select * from test_student where ( studentName like ? and ( id between ? and ? or this_.card_id is null))
 */
@SuppressWarnings("unchecked")
@Override
public List<Student> getStudentsByNameForHibernate(String studentName) {
	DetachedCriteria criteria = DetachedCriteria.forClass(Student.class);
	criteria.add(
		Restrictions.and(
			Restrictions.like("studentName", studentName, MatchMode.ANYWHERE),
			Restrictions.or(
				Restrictions.between("id", 1, 10),
				Restrictions.isNull("studentCard")
			)
		)
	);
	return (List<Student>) hibernateTemplate.findByCriteria(criteria);
}

 
@Override
public Student getStudentByIdForHibernate(Integer id) {
    return hibernateTemplate.get(Student.class, id);
}
@SuppressWarnings({ "unchecked", "deprecation" })
@Override
public Student getStudentByNameForHibernate(String studentName) {
    // Example 查询
    Student example = new Student();
    example.setStudentName(studentName);
    List<Student> students = hibernateTemplate.findByExample(example);
    // Hql 查询
    students = (List<Student>) hibernateTemplate.find("from Student where studentName like ?0", 
            String.format("%%%s%%", studentName));
    return students.isEmpty() ? null : students.get(0);
}
/**
 * criteria 多条件查询，示例 sql
 * select * from test_student where ( studentName like ? and ( id between ? and ? or this_.card_id is null))
 */
@SuppressWarnings("unchecked")
@Override
public List<Student> getStudentsByNameForHibernate(String studentName) {
    DetachedCriteria criteria = DetachedCriteria.forClass(Student.class);
    criteria.add(
        Restrictions.and(
            Restrictions.like("studentName", studentName, MatchMode.ANYWHERE),
            Restrictions.or(
                Restrictions.between("id", 1, 10),
                Restrictions.isNull("studentCard")
            )
        )
    );
    return (List<Student>) hibernateTemplate.findByCriteria(criteria);
}

StudentController.java

1
/** * 127.0.0.1/api/hibernate/student/9 ---- get */ @GetMapping("/hibernate/student/{id}") public Student getStudentByIdForHibernate(@PathVariable Integer id) { return studentService.getStudentByIdForHibernate(id); } /** * 127.0.0.1/api/hibernate/student?studentName=HymanHu ---- get */ @GetMapping("/hibernate/student") public Student getStudentByNameForHibernate(@RequestParam String studentName) { return studentService.getStudentByNameForHibernate(studentName); } /** * 127.0.0.1/api/hibernate/students?studentName=HymanHu ---- get */ @GetMapping("/hibernate/students") public List<Student> getStudentsForHibernate(@RequestParam(required = false) String studentName) { return studentService.getStudentsByNameForHibernate(studentName); }
1
/**
2
* 127.0.0.1/api/hibernate/student/9 ---- get
3
*/
4
@GetMapping("/hibernate/student/{id}")
5
public Student getStudentByIdForHibernate(@PathVariable Integer id) {
6
return studentService.getStudentByIdForHibernate(id);
7
}
8
9
/**
10
* 127.0.0.1/api/hibernate/student?studentName=HymanHu ---- get
11
*/
12
@GetMapping("/hibernate/student")
13
public Student getStudentByNameForHibernate(@RequestParam String studentName) {
14
return studentService.getStudentByNameForHibernate(studentName);
15
}
16
17
/**
18
* 127.0.0.1/api/hibernate/students?studentName=HymanHu ---- get
19
*/
20
@GetMapping("/hibernate/students")
21
public List<Student> getStudentsForHibernate(@RequestParam(required = false) String studentName) {
22
return studentService.getStudentsByNameForHibernate(studentName);
23
}
2

JPA

简介

JPA 是 Java Persistence API 的简称，是一套 Sun 公司 Java 官方制定的 ORM（Object Relational Mapping）方案，是规范、是标准，Sun 公司自己并没有实现；
市场上的主流的 JPA 框架有：Hibernate （JBoos）、EclipseTop（Eclipse社区）、OpenJPA （Apache基金会），Hibernate 是众多实现者之中，性能最好的，我们引入的 JPA 框架，采用 Hibernate 实现，需要注意的是，引用是 javax.persistence 这个“标准”包，和 org.hibernate 实现包；
JPA 想要做的就是尽量让你少写 Sql，甚至不写 Sql，基于这种思想，JPA 实现了它自己的一套语法、注解规则，JPA 要用各种注解配合来实现数据实体间一对多、多对多等关联关系，正因为这样，个人觉得实体变得不那么单纯，掺杂了逻辑在里面，这增加了实体的复杂度，对于比较复杂的业务来说，很容易造成实体间直接或间接的循环引用；
在此，我们引入将引入 Spring Data Jpa，在 JPA 之上添加另一层抽象（Repository 层的实现），极大地简化持久层开发；
Hibernate、JPA、Spring Data Jpa 之间的关系如下：

引入 Jar

spring-context
spring-orm
mysql-connector-java
c3p0
hibernate-core
spring-data-jpa
---------------- 已经引入的部分忽略 ----------------

 
<!-- Spring data jpa -->
<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-jpa</artifactId>
    <version>2.3.4.RELEASE</version>
</dependency>

配置

配置结构

applicationContext.xml ---- 全局配置，为了避免该文件杂乱，我们按功能拆分为子配置文件；

引入 jdbcParms.properties ---- Jdbc 配置信息；
引入 hibernateParms.properties ---- Hibernate 配置属性信息；
引入 springJpa.xml ---- JPA 注入 Spring 配置；

applicationContext.xml

 
<!-- 加载属性文件 -->
<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="locations">
       <list>
          <value>classpath:config/properties/jdbcParms.properties</value>
          <value>classpath:config/properties/hibernateParms.properties</value>
        </list>
    </property>
</bean>
<!-- 引入别的配置文件 -->
<import resource="springJpa.xml"/>

hibernateParms.properties

参见 Hibernate 相关配置；

springJpa.xml

配置链

dataSource ---- entityManagerFactory ---- transactionManager ---- jpa:repositories；

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" 
       xmlns:context="http://www.springframework.org/schema/context" 
       xmlns:aop="http://www.springframework.org/schema/aop" 
       xmlns:tx="http://www.springframework.org/schema/tx" 
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
       xmlns:jpa="http://www.springframework.org/schema/data/jpa" 
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
		http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
		http://www.springframework.org/schema/context 
		http://www.springframework.org/schema/context/spring-context-3.0.xsd 
		http://www.springframework.org/schema/mvc 
		http://www.springframework.org/schema/mvc/spring-mvc-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/data/jpa 
		http://www.springframework.org/schema/data/jpa/spring-jpa.xsd" >
		
	
	
	
	<bean id="dataSourceForJpa" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driverClassName}" />  
        <property name="jdbcUrl" value="${jdbc.url}" />  
        <property name="user" value="${jdbc.username}" />  
        <property name="password" value="${jdbc.password}" /> 
        
        
        <property name="acquireIncrement" value="${pool.acquireIncrement}" />
        
        <property name="initialPoolSize" value="${pool.initialPoolSize}" />
        <property name="minPoolSize" value="${pool.minPoolSize}" />
        <property name="maxPoolSize" value="${pool.maxPoolSize}" />
        
        <property name="autoCommitOnClose" value="${pool.autoCommitOnClose}"/>
    </bean>
    
    
	<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
		
		<property name="dataSource" ref="dataSourceForJpa" />
		
		<property name="packagesToScan" value="com.sfac.springMvc.module.*.entity" />
		
		<property name="persistenceProvider">
            <bean class="org.hibernate.jpa.HibernatePersistenceProvider" />
		</property>
		
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter" />
        </property>
		
		<property name="jpaProperties">
			<props>
				
				<prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>
				
				<prop key="hibernate.implicit_naming_strategy">${hibernate.implicit_naming_strategy}</prop>
				
				<prop key="hibernate.dialect">${hibernate.dialect}</prop>
				<prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
				<prop key="hibernate.format_sql">${hibernate.format_sql}</prop>
			</props>
		</property>
	</bean>
	
	
    <bean id="jpaTransactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory" />
    </bean>
    
    
    <tx:annotation-driven transaction-manager="jpaTransactionManager"/>
    
    
    <jpa:repositories base-package="com.sfac.springMvc.module.*.repository" 
    	transaction-manager-ref="jpaTransactionManager" 
    	entity-manager-factory-ref="entityManagerFactory" />
</beans>

 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" 
       xmlns:context="http://www.springframework.org/schema/context" 
       xmlns:aop="http://www.springframework.org/schema/aop" 
       xmlns:tx="http://www.springframework.org/schema/tx" 
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
       xmlns:jpa="http://www.springframework.org/schema/data/jpa" 
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context-3.0.xsd 
        http://www.springframework.org/schema/mvc 
        http://www.springframework.org/schema/mvc/spring-mvc-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/data/jpa 
        http://www.springframework.org/schema/data/jpa/spring-jpa.xsd" >
        
    <!-- 数据源，spring jdbc || c3p0 jdbc -->
    <!-- <bean id="dataSourceForJpa" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="${jdbc.driverClassName}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean> -->
    <!-- 配置 c3p0 数据源 -->
    <bean id="dataSourceForJpa" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driverClassName}" />  
        <property name="jdbcUrl" value="${jdbc.url}" />  
        <property name="user" value="${jdbc.username}" />  
        <property name="password" value="${jdbc.password}" /> 
        
        <!-- 连接池中连接用完时，c3p0 一次性创建的连接数 -->
        <property name="acquireIncrement" value="${pool.acquireIncrement}" />
        <!-- 初始化连接数，在 minPoolSize 和 maxPoolSize 之间 -->
        <property name="initialPoolSize" value="${pool.initialPoolSize}" />
        <property name="minPoolSize" value="${pool.minPoolSize}" />
        <property name="maxPoolSize" value="${pool.maxPoolSize}" />
        <!-- 连接关闭时默认将所有未提交的操作回滚,默认为 false -->
        <property name="autoCommitOnClose" value="${pool.autoCommitOnClose}"/>
    </bean>
    
    <!-- 配置 entityManagerFactory -->
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <!-- 设置数据源 -->
        <property name="dataSource" ref="dataSourceForJpa" />
        <!-- 扫描 Entity 包 -->
        <property name="packagesToScan" value="com.sfac.springMvc.module.*.entity" />
        <!-- 指定 JPA 实现厂商 -->
        <property name="persistenceProvider">
            <bean class="org.hibernate.jpa.HibernatePersistenceProvider" />
        </property>
        <!-- 指定 JPA 供应商适配器 -->
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter" />
        </property>
        <!-- 配置 JPA 属性 -->
        <property name="jpaProperties">
            <props>
                <!-- 动态生成表策略 -->
                <prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>
                <!-- 命名规则隐式策略 -->
                <prop key="hibernate.implicit_naming_strategy">${hibernate.implicit_naming_strategy}</prop>
                <!-- 数据库方言 -->
                <prop key="hibernate.dialect">${hibernate.dialect}</prop>
                <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
                <prop key="hibernate.format_sql">${hibernate.format_sql}</prop>
            </props>
        </property>
    </bean>
    
    <!-- 配置事务管理器 -->
    <bean id="jpaTransactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory" />
    </bean>
    
    <!-- 开启事务注解 -->
    <tx:annotation-driven transaction-manager="jpaTransactionManager"/>
    
    <!-- 配置 repository -->
    <jpa:repositories base-package="com.sfac.springMvc.module.*.repository" 
        transaction-manager-ref="jpaTransactionManager" 
        entity-manager-factory-ref="entityManagerFactory" />
</beans>

应用

主要接口和实现类

Repository

属性查询

接口方法命名：

findBy + 属性 + 关键字 + 属性（option）；
find + Top || First（option） + By + 属性 + 关键字 + 属性（option）；

查询关键字列表

And ---- findByLastnameAndFirstname ---- … where x.lastname = ?1 and x.firstname = ?2；
Or ---- findByLastnameOrFirstname ---- … where x.lastname = ?1 or x.firstname = ?2；
Is,Equals ---- findByFirstname,findByFirstnameIs,findByFirstnameEquals ---- … where x.firstname = ?1；
Between ---- findByStartDateBetween ---- … where x.startDate between ?1 and ?2；
LessThan ---- findByAgeLessThan ---- … where x.age < ?1；
LessThanEqual ---- findByAgeLessThanEqual ---- … where x.age <= ?1；
GreaterThan ---- findByAgeGreaterThan ---- … where x.age > ?1；
GreaterThanEqual ---- findByAgeGreaterThanEqual ---- … where x.age >= ?1；
After ---- findByStartDateAfter ---- … where x.startDate > ?1；
Before ---- findByStartDateBefore ---- … where x.startDate < ?1；
IsNull ---- findByAgeIsNull ---- … where x.age is null；
IsNotNull,NotNull ---- findByAge(Is)NotNull ---- … where x.age not null；
Like ---- findByFirstnameLike ---- … where x.firstname like ?1；
NotLike ---- findByFirstnameNotLike ---- … where x.firstname not like ?1；
StartingWith ---- findByFirstnameStartingWith ---- … where x.firstname like ?1 (parameter bound with appended %)；
EndingWith ---- findByFirstnameEndingWith ---- … where x.firstname like ?1 (parameter bound with prepended %)；
Containing ---- findByFirstnameContaining ---- … where x.firstname like ?1 (parameter bound wrapped in %)；
OrderBy ---- findByAgeOrderByLastnameDesc ---- … where x.age = ?1 order by x.lastname desc；
Not ---- findByLastnameNot ---- … where x.lastname <> ?1；
In ---- findByAgeIn(Collection<Age> ages) ---- … where x.age in ?1；
NotIn ---- findByAgeNotIn(Collection<Age> ages) ---- … where x.age not in ?1；
True ---- findByActiveTrue() ---- … where x.active = true；
False ---- findByActiveFalse() ---- … where x.active = false；
IgnoreCase ---- findByFirstnameIgnoreCase ---- … where UPPER(x.firstame) = UPPER(?1)；

@Query 注解查询；

查询语言

SQL 语言

关系型数据库查询语言；
select name, age, user_id from t_user;
JPA 中使用 Sql 语句，只需注解中添加参数 nativeQuery = true 即可；

HQL 语言

Hibernate 造出来的对象语言，只有 Hibernate 框架能够解析，并将其通过一系列的映射转换，拼凑成 SQL 语言；
使用 “类名” 取代 “表名”，用 “类名.属性名” 取代 “表名.列名”，类名建议不要省略；
没有 * 查询，使用 from 类名代替；
查询操作使用 @Query 注解
删除修改操作使用 @Modifying + @Transactional + @Query 注解，@Transactional 可加在 service 层；

JPQL 语言

EJB3.0 中的 JPA 造出来的对象查询语言，其原型类似于 HQL，Sun 看到 Hibernate 做的 ORM 技术做的非常好，成为行业内领导 ORM 框架的主流产品，故 Sun 将其吸收进 EJB3 中，制定了一套 ORM 的 JAVA API 标准；

传参方式

select name,age,userId from User where userName = ?1; ---- ?加数字表示占位符，从 1 开始；
select name,age,userId from User where userName=:userName; ---- :加上变量名，这里是与方法参数中有 @PARAM 的值匹配；

CrudRepository

添加了对数据的增删改查的方法；

PagingAndSortingRepository

添加了对数据的分页和排序方法；

QueryByExampleExecutor

Example 条件查询；

JpaRepository

对继承父接口中方法的返回值进行了适配，在父类接口中通常都返回迭代器，需要我们自己进行强制类型转化，而在 JpaRepository 中，直接返回了 List；

JpaSpecificationExecutor

主要提供了多条件查询的支持，并且可以在查询中添加分页和排序，因为这个接口单独存在，因此需要配合以上说的接口使用；

QueryDslPredicateExecutor
SimpleJpaRepository ---- 实现类；
QueryDslJpaRepository ---- 实现类；

新增接口

针对每个 Bean 书写一个持久层接口，继承 JpaRepository<T, ID> 接口（其中 T 是实体 bean， ID 是主键），添加 @Repository 注解，到此，我们一行代码都不用写，即可调用父接口实现功能；
StudentRepository.java

 
@Repository
public interface StudentRepository extends JpaRepository<Student, Integer> {
}

StudentServiceImpl.java

 
@Autowired
private StudentRepository studentRepository;
@Override
@Transactional("jpaTransactionManager")
public ResultEntity<Student> insertStudentForJpa(Student student) {
    studentRepository.saveAndFlush(student);
    return new ResultEntity<Student>(ResultStatus.SUCCESS.status, "Insert success.", student);
}

StudentController.java

 
/**
 * 127.0.0.1/api/jpa/student ---- post
 * {"studentName":"HymanHu"}
 * {"studentName":"HymanHu", "studentCard":{"cardNo":"studentCard001"}}
 */
@PostMapping(value = "/jpa/student", consumes = "application/json")
public ResultEntity<Student> insertStudentForJpa(@RequestBody Student student) {
    return studentService.insertStudentForJpa(student);
}

修改接口

StudentServiceImpl.java

 
@Override
@Transactional("jpaTransactionManager")
public ResultEntity<Student> updateStudentForJpa(Student student) {
    studentRepository.saveAndFlush(student);
//  int i = 1 / 0;
    return new ResultEntity<Student>(ResultStatus.SUCCESS.status, "Update success.", student);
}

StudentController.java

 
/**
 * 127.0.0.1/api/jpa/student ---- put
 * {"id":"2","studentName":"HymanHu1"}
 * {"id":"2","studentName":"HymanHu1","studentCard":{"id":"1","cardNo":"studentCard002"}}
 */
@PutMapping(value = "/jpa/student", consumes = "application/json")
public ResultEntity<Student> updateStudentForJpa(@RequestBody Student student) {
    return studentService.updateStudentForJpa(student);
}

删除接口

StudentServiceImpl.java

 
@Override
public ResultEntity<Object> deleteStudentForJpa(Integer id) {
    studentRepository.deleteById(id);
    return new ResultEntity<Object>(ResultStatus.SUCCESS.status, "Delete success.");
}

StudentController.java

 
/**
 * 127.0.0.1/api/jpa/student/2 ---- delete
 */
@DeleteMapping("/jpa/student/{id}")
public ResultEntity<Object> deleteStudentForJpa(@PathVariable Integer id) {
    return studentService.deleteStudentForJpa(id);
}

父接口查询

StudentServiceImpl.java

 
@Override
public Student getStudentByIdForJpa(Integer id) {
    return studentRepository.findById(id).orElse(null);
}
@Override
public List<Student> getStudentsForJpa() {
    return studentRepository.findAll();
}

StudentController.java

1
/** * 127.0.0.1/api/jpa/student/9 ---- get */ @GetMapping("/jpa/student/{id}") public Student getStudentByIdForJpa(@PathVariable Integer id) { return studentService.getStudentByIdForJpa(id); } /** * 127.0.0.1/api/jpa/students ---- get */ @GetMapping("/jpa/students") public List<Student> getStudentsForJpa(@RequestParam(required = false) String studentName) { return studentService.getStudentsForJpa(); }
1
/**
2
* 127.0.0.1/api/jpa/student/9 ---- get
3
*/
4
@GetMapping("/jpa/student/{id}")
5
public Student getStudentByIdForJpa(@PathVariable Integer id) {
6
return studentService.getStudentByIdForJpa(id);
7
}
8
/**
9
* 127.0.0.1/api/jpa/students ---- get
10
*/
11
@GetMapping("/jpa/students")
12
public List<Student> getStudentsForJpa(@RequestParam(required = false) String studentName) {
13
return studentService.getStudentsForJpa();
14
}
2

Example && Criteria 查询

JpaRepository：<S extends T> Page<S> findAll(Example<S> example, Pageable pageable);

Example：动态条件查询样本 ----static <T> Example<T> of(T probe, ExampleMatcher matcher)；

T：实体 bean；
ExampleMatcher：查询匹配器；

ExampleMatcher.matchingAny() ---- 匹配条件是 or 的关系；
ExampleMatcher.matching() ---- 匹配条件是 and 的关系；
withMatcher("studentName", match -> match.contains()) ---- 模糊查询，即 %studentName%；
withIgnorePaths("studentId", "createDate"); ---- 忽略字段，可以自动忽略空值的字段，但 id 是基本数据类型，默认值为 0，必须忽略；

Pageable：分页组件 ---- public static PageRequest of(int page, int size, Sort sort)；

page：当前页，从 0 开始；
size：每页大小；
sort：排序对象 ---- new Sort(direction, orderBy)；

direction：排序方向，Sort.Direction.ASC；
orderBy：排序字段；

Page：返回分页对象；

JpaSpecificationExecutor：Page findAll(@Nullable Specification<T> spec, Pageable pageable);

Specification：Criteria 多条件查询，支持时间比较、数字比较等；
Pageable
Page

StudentRepository.java

 
@Repository
public interface StudentRepository extends JpaRepository<Student, Integer>, JpaSpecificationExecutor<Student> {
}

StudentServiceImpl.java

@Override
public Page<Student> getStudentsBySearchBeanForJpa(SearchBean searchBean) {
	searchBean.initSearchBean();
//		Page<Student> page = exampleAndPage(searchBean);
	Page<Student> page = criteriaAndPage(searchBean);
	return page;
}

/**
 * -实现方式一：Example + Page 查询
 */
public Page<Student> exampleAndPage(SearchBean searchBean) {
	// 创建 Pageable 对象
	String orderBy = StringUtils.isBlank(searchBean.getOrderBy()) ? "id" : searchBean.getOrderBy();
	Sort.Direction direction = StringUtils.isBlank(searchBean.getDirection()) || 
			searchBean.getDirection().equalsIgnoreCase("asc") ? Sort.Direction.ASC : Sort.Direction.DESC;
	Sort sort = new Sort(direction, orderBy);
	// 当前页起始为 0
	Pageable pageable = PageRequest.of(searchBean.getCurrentPage() - 1, searchBean.getPageSize(), sort);
	
	// 创建 Example 对象
	Student student = new Student();
	student.setStudentName(searchBean.getKeyWord());
	student.setCreateDate(LocalDateTime.of(2021, 1, 19, 0, 0));
	// matchingAny 相当于 or 连接查询条件，matching 相当于 and 连接查询条件
	ExampleMatcher exampleMatcher = ExampleMatcher.matchingAny()
			// 模糊查询，即 %{studentName} %
			.withMatcher("studentName", match -> match.contains())
			// 时间类型不支持模糊查询，生成的语句为createDate=?，同时也不支持 id > startId && id < endId 这样的操作
			.withMatcher("createDate", match -> match.contains())
			// 忽略基本数据类型字段，如果使用包装类则无需忽略
			.withIgnorePaths("id");
	Example<Student> example = Example.of(student, exampleMatcher);
	
	return studentRepository.findAll(example, pageable);
}

/**
 * -实现方式：Criteria + Page
 */
public Page<Student> criteriaAndPage(SearchBean searchBean) {
	// 创建 Pageable 对象
	String orderBy = StringUtils.isBlank(searchBean.getOrderBy()) ? "id" : searchBean.getOrderBy();
	Sort.Direction direction = StringUtils.isBlank(searchBean.getDirection()) || 
			searchBean.getDirection().equalsIgnoreCase("asc") ? Sort.Direction.ASC : Sort.Direction.DESC;
	Sort sort = new Sort(direction, orderBy);
	// 当前页起始为 0
	Pageable pageable = PageRequest.of(searchBean.getCurrentPage() - 1, searchBean.getPageSize(), sort);
	
	// 创建 Specification 对象
	Specification<Student> specification = new Specification<Student>() {
		private static final long serialVersionUID = 1L;

/**
		 * -构造语句 select * from test_student where createDate>=? and 
		 * (studentName like ? or id between 10 and 20) order by id desc limit ?
		 */
		@Override
		public Predicate toPredicate(Root<Student> root, CriteriaQuery<?> query, 
				CriteriaBuilder criteriaBuilder) {
			
			return criteriaBuilder.and(
				criteriaBuilder.greaterThanOrEqualTo(
					root.get("createDate").as(LocalDateTime.class), 
					LocalDateTime.of(2021, 1, 20, 0, 0)),
				criteriaBuilder.or(
					criteriaBuilder.like(root.get("studentName").as(String.class), 
							String.format("%%%s%%", searchBean.getKeyWord())),
					criteriaBuilder.between(root.get("id"), 10, 20)
				)
			);
		}
	};
	
	return studentRepository.findAll(specification, pageable);
}

 
@Override
public Page<Student> getStudentsBySearchBeanForJpa(SearchBean searchBean) {
    searchBean.initSearchBean();
//      Page<Student> page = exampleAndPage(searchBean);
    Page<Student> page = criteriaAndPage(searchBean);
    return page;
}
/**
 * -实现方式一：Example + Page 查询
 */
public Page<Student> exampleAndPage(SearchBean searchBean) {
    // 创建 Pageable 对象
    String orderBy = StringUtils.isBlank(searchBean.getOrderBy()) ? "id" : searchBean.getOrderBy();
    Sort.Direction direction = StringUtils.isBlank(searchBean.getDirection()) || 
            searchBean.getDirection().equalsIgnoreCase("asc") ? Sort.Direction.ASC : Sort.Direction.DESC;
    Sort sort = new Sort(direction, orderBy);
    // 当前页起始为 0
    Pageable pageable = PageRequest.of(searchBean.getCurrentPage() - 1, searchBean.getPageSize(), sort);
    
    // 创建 Example 对象
    Student student = new Student();
    student.setStudentName(searchBean.getKeyWord());
    student.setCreateDate(LocalDateTime.of(2021, 1, 19, 0, 0));
    // matchingAny 相当于 or 连接查询条件，matching 相当于 and 连接查询条件
    ExampleMatcher exampleMatcher = ExampleMatcher.matchingAny()
            // 模糊查询，即 %{studentName} %
            .withMatcher("studentName", match -> match.contains())
            // 时间类型不支持模糊查询，生成的语句为createDate=?，同时也不支持 id > startId && id < endId 这样的操作
            .withMatcher("createDate", match -> match.contains())
            // 忽略基本数据类型字段，如果使用包装类则无需忽略
            .withIgnorePaths("id");
    Example<Student> example = Example.of(student, exampleMatcher);
    
    return studentRepository.findAll(example, pageable);
}
/**
 * -实现方式：Criteria + Page
 */
public Page<Student> criteriaAndPage(SearchBean searchBean) {
    // 创建 Pageable 对象
    String orderBy = StringUtils.isBlank(searchBean.getOrderBy()) ? "id" : searchBean.getOrderBy();
    Sort.Direction direction = StringUtils.isBlank(searchBean.getDirection()) || 
            searchBean.getDirection().equalsIgnoreCase("asc") ? Sort.Direction.ASC : Sort.Direction.DESC;
    Sort sort = new Sort(direction, orderBy);
    // 当前页起始为 0
    Pageable pageable = PageRequest.of(searchBean.getCurrentPage() - 1, searchBean.getPageSize(), sort);
    
    // 创建 Specification 对象
    Specification<Student> specification = new Specification<Student>() {
        private static final long serialVersionUID = 1L;
        /**
         * -构造语句 select * from test_student where createDate>=? and 
         * (studentName like ? or id between 10 and 20) order by id desc limit ?
         */
        @Override
        public Predicate toPredicate(Root<Student> root, CriteriaQuery<?> query, 
                CriteriaBuilder criteriaBuilder) {
            
            return criteriaBuilder.and(
                criteriaBuilder.greaterThanOrEqualTo(
                    root.get("createDate").as(LocalDateTime.class), 
                    LocalDateTime.of(2021, 1, 20, 0, 0)),
                criteriaBuilder.or(
                    criteriaBuilder.like(root.get("studentName").as(String.class), 
                            String.format("%%%s%%", searchBean.getKeyWord())),
                    criteriaBuilder.between(root.get("id"), 10, 20)
                )
            );
        }
    };
    
    return studentRepository.findAll(specification, pageable);
}

StudentController.java

 
/**
 * 127.0.0.1/api/jpa/students ---- post
 * {"currentPage":1, "pageSize":5, "keyWord":"hy", "orderBy":"id", "direction":"desc"}
 * {"currentPage":1, "pageSize":5, "keyWord":"hu", "orderBy":"studentName", "direction":"asc"}
 * -注意：排序字段不能使用下划线
 * 
 */
@PostMapping(value = "/jpa/students", consumes = "application/json")
public Page<Student> getStudentsBySearchBeanForJpa(@RequestBody SearchBean searchBean) {
    return studentService.getStudentsBySearchBeanForJpa(searchBean);
}

属性查询

StudentRepository.java

 
List<Student> findByStudentName(String studentName);

StudentServiceImpl.java

 
@Override
public Student getStudentByNameForJpa(String studentName) {
    List<Student> students = Optional.ofNullable(studentRepository.findByStudentName(studentName))
            .orElse(Collections.emptyList());
    return students.isEmpty() ? null : students.get(0);
}

StudentController.java

 
/**
 * 127.0.0.1/api/jpa/student?studentName=HymanHu ---- get
 */
@GetMapping("/jpa/student")
public Student getStudentByNameForJpa(@RequestParam String studentName) {
    return studentService.getStudentByNameForJpa(studentName);
}

Sql && Hql 查询

StudentRepository.java

 
//@Query(nativeQuery = true, value = "select * from test_student where id = :id")
@Query(value = "from Student where id = :id")
Student getStudentById(@Param("id") Integer id);
@Modifying
//@Query(nativeQuery = true, value = "update test_student set student_name = :studentName where id = :id")
@Query(value = "update Student set studentName = :studentName where id = :id")
void updateStudentName(@Param("studentName") String studentName, @Param("id") Integer id);
@Modifying
@Query(nativeQuery = true, value = "update test_student " +
        "set student_name = :#{#student.studentName} where id = :#{#student.id}")
void updateStudent(@Param("student") Student student);

StudentServiceImpl.java

 
@Override
public Student getStudentByIdV2ForJpa(Integer id) {
    return studentRepository.getStudentById(id);
}
@Override
@Transactional("jpaTransactionManager")
public ResultEntity<Student> updateStudentNameForJpa(Student student) {
    studentRepository.updateStudentName(student.getStudentName(), student.getId());
    return new ResultEntity<Student>(ResultStatus.SUCCESS.status, "Update success.", student);
}

StudentController.java

1
/** * 127.0.0.1/api/jpa/student/2/v2 ---- get */ @GetMapping("/jpa/student/{id}/v2") public Student getStudentByIdV2ForJpa(@PathVariable Integer id) { return studentService.getStudentByIdV2ForJpa(id); } /** * 127.0.0.1/api/jpa/student/v2 ---- put * {"id":"1","studentName":"HymanHu1"} */ @PutMapping(value = "/jpa/student/v2",consumes = "application/json") public ResultEntity<Student> updateStudentNameForJpa(@RequestBody Student student) { return studentService.updateStudentNameForJpa(student); }
1
/**
2
* 127.0.0.1/api/jpa/student/2/v2 ---- get
3
*/
4
@GetMapping("/jpa/student/{id}/v2")
5
public Student getStudentByIdV2ForJpa(@PathVariable Integer id) {
6
return studentService.getStudentByIdV2ForJpa(id);
7
}
8
9
/**
10
* 127.0.0.1/api/jpa/student/v2 ---- put
11
* {"id":"1","studentName":"HymanHu1"}
12
*/
13
@PutMapping(value = "/jpa/student/v2",consumes = "application/json")
14
public ResultEntity<Student> updateStudentNameForJpa(@RequestBody Student student) {
15
return studentService.updateStudentNameForJpa(student);
16
}
2

批量接口

思路

方式一：父接口中有 saveAll、deleteInBatch 方法，可完成批量增删改操作，在此不做赘述；
方式二：引入 @persistencecontext 注解和 EntityManager 类，属于 Jpa 包，用途是将 Entity 在内存操作，处理完成之后再一次性同步到数据库，效率要比第一种方式高；

StudentServiceImpl.java

 
@PersistenceContext
private EntityManager entityManager;
@Override
@Transactional
public ResultEntity<List<Student>> batchInsertStudentsForJpa(List<Student> students) {
    // 方式一，调用父接口完成批量操作
//      studentRepository.saveAll(students);
//      studentRepository.flush();
    
    // 方式二，引入 entityManager 进行批量操作，效率高于第一种方式
    students.stream().forEach(item -> {
        entityManager.persist(item);
    });
    entityManager.flush();
    entityManager.clear();
    return new ResultEntity<List<Student>>(ResultStatus.SUCCESS.status, "Update success.", students);
}

StudentController.java

 
/**
 * 127.0.0.1/api/jpa/students/v2 ---- post
 * [{"studentName":"aa1"},{"studentName":"aa2"}]
 */
@PostMapping(value = "/jpa/students/v2", consumes = "application/json")
public ResultEntity<List<Student>> batchInsertStudentsForJpa(@RequestBody List<Student> students) {
    return studentService.batchInsertStudentsForJpa(students);
}

练习

创建 User、Role、UserRole、Resource、RoleResource 五个 Bean，使用 Jpa 自动生成表（中间表不要外键关系），使用 Mybatis Or Jpa 实现 User、 Role、Resource 的增删改查接口；

JSP

引入

pom 引入：javax.servlet-api、jsp-api、jstl（Jsp 标准标签库）、taglibs-standard-impl（支持 taglibs 指令）；

 
<!-- Jsp 支持 -->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.1</version>
    <scope>provided</scope>
</dependency>
<dependency>
    <groupId>javax.servlet.jsp</groupId>
    <artifactId>javax.servlet.jsp-api</artifactId>
    <version>2.3.3</version>
    <scope>provided</scope>
</dependency>
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
    <version>1.2</version>
</dependency>
<dependency>
    <groupId>org.apache.taglibs</groupId>
    <artifactId>taglibs-standard-impl</artifactId>
    <version>1.2.5</version>
</dependency>

配置

springMvcConfig.xml 配置视图解析器 InternalResourceViewResolver；

我们的 Jsp 文件放到 src/main/webapp/WEB_INF/templates 文件夹下，页面的物理视图路劲 = 前缀 + 逻辑视图名 + 后缀，我们在控制器中只需要返回“逻辑视图名”即可；

 
<!-- 视图解析器 -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"   
    p:prefix="/WEB-INF/templates/" p:suffix=".jsp"></bean>

应用

页面模块化

根据页面的功能，分成不同模块页面，在前端进行分包治理，与后端一一对应；
前端后端分包如下：
如图所示，后台 module 包下，按照模块分成了 common、test 两个模块，对应到前端 templates 包下，也一一对应了 common 模块页面文件夹、test 模块页面文件夹，新增模块以此类推，保持前后端模块一一对应；

页面碎片化

将页面中公共的部分拆分出来形成单独的碎片页面，再通过碎片组装器，将碎片组装成完整的页面；
来看下面两张图片，这是后台管理系统中常见的页面布局；

第一张：登录和注册页面，样式类似，面板标签不同而已；
第二张：dashboard 页面，点击左边的菜单栏，中间 body 部分改为不同的内容；

页面拆分 && 组装

templates\fragments\header.jsp：公共的头部信息；
templates\fragments\sideBar.jsp：公共的左侧菜单信息，有时候也将这部分内容和 header.html 放在一起；
templates\fragments\footer.jsp：公共底部信息；
内容展示区：页面展示的不同区域；
整张页面通过 Jsp include 指令完成：<%@ include file="/fragments/header.jsp"%>

寻找前端模版

目标：寻找一个开源的、关于后台管理系统的、基于 jQuery 和 Bootstrap 的、易于拆解的前端模版，移植到我们的项目中；
百度、谷歌、CSDN、GitHub…… 搜索到 CSDN 博客 https://blog.csdn.net/sinat_40770656/article/details/95058150，该博客列举了十个开源前端模版，源码转到 GitHub；
GitHub地址；

AdminLTE：https://github.com/ColorlibHQ/AdminLTE
Gentelella Admin：https://github.com/ColorlibHQ/gentelella
Vali Admin：https://github.com/pratikborsadiya/vali-admin
ModularAdmin：https://github.com/modularcode/modular-admin-html
Metis：https://github.com/puikinsh/Bootstrap-Admin-Template
Ace：https://github.com/bopoda/ace
Light Bootstrap Dashboard：https://github.com/creativetimofficial/light-bootstrap-dashboard
Material Dashboard：https://github.com/creativetimofficial/material-dashboard
Clearmin：https://github.com/paomedia/clearmin
SB-Admin-2：https://github.com/BlackrockDigital/startbootstrap-sb-admin-2

模板要求：有源码、可以演示、有登录页面、注册页面、列表处理页面、日历处理页面、图表页面、个人主页、错误页面、元素组件……

移植前端模版

页面模版：Ace（Jquery + Bootstramp），https://github.com/bopoda/ace；
移植模版中的静态资源文件到 /static 文件夹下；
将 dashboard 主页作为拆解对象，按照其网页结构分解出 header.jsp、sidebar.jsp、footer.jsp，然后在 dashboard 中引入碎片页面；
创建控制器返回拆解好的 dashboard.jsp 进行测试调试；
其他页面按照 dashboard.jsp 网页结构进行构造；

Fragment 碎片文件

header.jsp
sidebar.jsp
footer.jsp

Dashboad 页面

dashboard.jsp
CommonController.java

Test 主页

index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt" %>

<!DOCTYPE html>
<html lang="en">
<head>
	<meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1" />
	<meta charset="utf-8" />
	<meta name="description" content="overview &amp; stats" />
	<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0" />
	<title>Java_Spring_Mvc</title>
	
	
	
	<link href="/static/css/bootstrap.min.css" rel="stylesheet" />
	
	<link href="/static/font-awesome/4.5.0/css/font-awesome.min.css" rel="stylesheet" />
	
	<link href="/static/css/fonts.googleapis.com.css" rel="stylesheet" />
	
	<link href="/static/css/ace.min.css" class="ace-main-stylesheet" id="main-ace-style" rel="stylesheet" />
	<link href="/static/css/ace-skins.min.css" rel="stylesheet" />
	<link href="/static/css/ace-rtl.min.css" rel="stylesheet" />
</head>
<body class="no-skin">
	
	<%@ include file="../fragments/header.jsp"%>
	
	<div class="main-container ace-save-state" id="main-container">
		
		<%@ include file="../fragments/sidebar.jsp"%>

<div class="main-content">
			<div class="main-content-inner">
				<div class="breadcrumbs ace-save-state" id="breadcrumbs">
					<ul class="breadcrumb">
						<li><i class="ace-icon fa fa-home home-icon"></i><a href="#">Home</a></li>
						<li class="active">Test</li>
					</ul>

<div class="page-content">
					<div class="page-header">
						<h1> Test <small>
							<i class="ace-icon fa fa-angle-double-right"></i> index page </small>
						</h1>
					</div>

<div class="row">
						<div class="col-xs-12">
							<div class="row">
								<div class="space-6"></div>
								<h1>This is jsp test index page.</h1>
								<h3>获取变量</h3>
								<p>userName: ${userName }</p>
								<p>==================================================================</p>
								<h3>数据格式化</h3>
								<p>Date格式化: <fmt:formatDate value="${current1}" pattern="yyyy-MM-dd HH:mm:ss"/></p>
								<p>LocalDateTime格式化: 
									<fmt:parseDate value="${current2}" pattern="y-M-dd'T'H:m:s" var="myParseDate"></fmt:parseDate> 
									<fmt:formatDate value="${myParseDate}"  pattern="yyyy-MM-dd HH:mm:ss"></fmt:formatDate >
								</p>
								<p>数字式化百分比: <fmt:formatNumber type="percent" value="${number / 100 }" maxFractionDigits="3" />
								<p>数字式化货币: <fmt:formatNumber type="currency" value="${number }" />
								<p>数字式化: <fmt:formatNumber type="number" value="${number }" maxFractionDigits="2" />
								<p>==================================================================</p>
								<h3>判断标签</h3>
								<c:set var="title" scope="page" value="青年"/>
								<c:if test="${age > 10 && age < 20}">
								   <p>称谓: <c:out value="${title}"/><p>
								</c:if>
								<c:choose>
									<c:when test="${age < 10}">
										<p>称谓: 儿童<p>
									</c:when>
									<c:when test="${age >= 10 && age < 30}">
										<p>称谓: 青年<p>
									</c:when>
									<c:when test="${age >= 30 && age < 50}">
										<p>称谓: 中年<p>
									</c:when>
									<c:otherwise>
										<p>称谓: 老年<p>
									</c:otherwise>
								</c:choose>
								<p>==================================================================</p>
								<h3>循环标签</h3>
								<ul>
									<c:forEach var="city" items="${cities }">
										<li>${city.cityName }</li>
									</c:forEach>
								</ul>
								<table>
									<thead><tr><td>Id</td><td>CityName</td></tr></thead>
									<tbody>
										<c:forEach var="city" items="${cities }">
											<tr><td>${city.cityId }</td><td>${city.cityName }</td></tr>
										</c:forEach>
									</tbody>
								</table>
								<select>
									<c:forEach var="city" items="${cities }">
										<option id="${city.cityId }">${city.cityName }</option>
									</c:forEach>
								</select>
								<p>==================================================================</p>
								<h3>Form</h3>
								<form action="/test/city" method="post">
									<input type="hidden" name="_method" value="put">
									<input type="hidden" value="${city.cityId }" name="cityId" />
									<p>City Name: <input type="text" name="cityName" value="${city.cityName }" /></p>
									<p>Local City Name: <input type="text" name="localCityName" value="${city.localCityName }"/></p>
									<p><button type="submit">Submit</button></p>
								</form>
								<p>==================================================================</p>
							</div>
						</div>
					</div>
				</div>
				
			</div>
		</div>

<%@ include file="../fragments/footer.jsp"%>
	</div>

<script src="/static/js/jquery-2.1.4.min.js"></script>
	<script src="/static/js/bootstrap.min.js"></script>
	<script src="/static/js/ace-elements.min.js"></script>
	<script src="/static/js/ace.min.js"></script>
	<script src="/static/js/ace-extra.min.js"></script>
	<script src="/static/js/custom.js"></script>
</body>
</html>

 
<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt" %>
<!DOCTYPE html>
<html lang="en">
<head>
    <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1" />
    <meta charset="utf-8" />
    <meta name="description" content="overview &amp; stats" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0" />
    <title>Java_Spring_Mvc</title>
    
    <!-- css -->
    <!-- bootstrap -->
    <link href="/static/css/bootstrap.min.css" rel="stylesheet" />
    <!-- fontawesome -->
    <link href="/static/font-awesome/4.5.0/css/font-awesome.min.css" rel="stylesheet" />
    <!-- text fonts -->
    <link href="/static/css/fonts.googleapis.com.css" rel="stylesheet" />
    <!-- ace styles -->
    <link href="/static/css/ace.min.css" class="ace-main-stylesheet" id="main-ace-style" rel="stylesheet" />
    <link href="/static/css/ace-skins.min.css" rel="stylesheet" />
    <link href="/static/css/ace-rtl.min.css" rel="stylesheet" />
</head>
<body class="no-skin">
    <!-- header -->
    <%@ include file="../fragments/header.jsp"%>
    
    <div class="main-container ace-save-state" id="main-container">
        <!-- sidebar -->
        <%@ include file="../fragments/sidebar.jsp"%>
        <!-- main content -->
        <div class="main-content">
            <div class="main-content-inner">
                <div class="breadcrumbs ace-save-state" id="breadcrumbs">
                    <ul class="breadcrumb">
                        <li><i class="ace-icon fa fa-home home-icon"></i><a href="#">Home</a></li>
                        <li class="active">Test</li>
                    </ul>
                    <div class="nav-search" id="nav-search">
                        <form class="form-search">
                            <span class="input-icon">
                                <input type="text" placeholder="Search ..." class="nav-search-input"
                                    id="nav-search-input" autocomplete="off" />
                                <i class="ace-icon fa fa-search nav-search-icon"></i>
                            </span>
                        </form>
                    </div>
                </div>
                <div class="page-content">
                    <div class="page-header">
                        <h1> Test <small>
                            <i class="ace-icon fa fa-angle-double-right"></i> index page </small>
                        </h1>
                    </div>
                    <!-- /.page-header -->
                    <div class="row">
                        <div class="col-xs-12">
                            <div class="row">
                                <div class="space-6"></div>
                                <h1>This is jsp test index page.</h1>
                                <h3>获取变量</h3>
                                <p>userName: ${userName }</p>
                                <p>==================================================================</p>
                                <h3>数据格式化</h3>
                                <p>Date格式化: <fmt:formatDate value="${current1}" pattern="yyyy-MM-dd HH:mm:ss"/></p>
                                <p>LocalDateTime格式化: 
                                    <fmt:parseDate value="${current2}" pattern="y-M-dd'T'H:m:s" var="myParseDate"></fmt:parseDate> 
                                    <fmt:formatDate value="${myParseDate}"  pattern="yyyy-MM-dd HH:mm:ss"></fmt:formatDate >
                                </p>
                                <p>数字式化百分比: <fmt:formatNumber type="percent" value="${number / 100 }" maxFractionDigits="3" />
                                <p>数字式化货币: <fmt:formatNumber type="currency" value="${number }" />
                                <p>数字式化: <fmt:formatNumber type="number" value="${number }" maxFractionDigits="2" />
                                <p>==================================================================</p>
                                <h3>判断标签</h3>
                                <c:set var="title" scope="page" value="青年"/>
                                <c:if test="${age > 10 && age < 20}">
                                   <p>称谓: <c:out value="${title}"/><p>
                                </c:if>
                                <c:choose>
                                    <c:when test="${age < 10}">
                                        <p>称谓: 儿童<p>
                                    </c:when>
                                    <c:when test="${age >= 10 && age < 30}">
                                        <p>称谓: 青年<p>
                                    </c:when>
                                    <c:when test="${age >= 30 && age < 50}">
                                        <p>称谓: 中年<p>
                                    </c:when>
                                    <c:otherwise>
                                        <p>称谓: 老年<p>
                                    </c:otherwise>
                                </c:choose>
                                <p>==================================================================</p>
                                <h3>循环标签</h3>
                                <ul>
                                    <c:forEach var="city" items="${cities }">
                                        <li>${city.cityName }</li>
                                    </c:forEach>
                                </ul>
                                <table>
                                    <thead><tr><td>Id</td><td>CityName</td></tr></thead>
                                    <tbody>
                                        <c:forEach var="city" items="${cities }">
                                            <tr><td>${city.cityId }</td><td>${city.cityName }</td></tr>
                                        </c:forEach>
                                    </tbody>
                                </table>
                                <select>
                                    <c:forEach var="city" items="${cities }">
                                        <option id="${city.cityId }">${city.cityName }</option>
                                    </c:forEach>
                                </select>
                                <p>==================================================================</p>
                                <h3>Form</h3>
                                <form action="/test/city" method="post">
                                    <input type="hidden" name="_method" value="put">
                                    <input type="hidden" value="${city.cityId }" name="cityId" />
                                    <p>City Name: <input type="text" name="cityName" value="${city.cityName }" /></p>
                                    <p>Local City Name: <input type="text" name="localCityName" value="${city.localCityName }"/></p>
                                    <p><button type="submit">Submit</button></p>
                                </form>
                                <p>==================================================================</p>
                            </div>
                        </div>
                    </div>
                </div>
                <!-- /.page-content -->
            </div>
        </div>
        <!-- /.main-content -->
        <!-- footer -->
        <%@ include file="../fragments/footer.jsp"%>
    </div>
    <!-- /.main-container -->
    <!-- js -->
    <script src="/static/js/jquery-2.1.4.min.js"></script>
    <script src="/static/js/bootstrap.min.js"></script>
    <script src="/static/js/ace-elements.min.js"></script>
    <script src="/static/js/ace.min.js"></script>
    <script src="/static/js/ace-extra.min.js"></script>
    <script src="/static/js/custom.js"></script>
</body>
</html>

TestController.java

 
/**
 * 127.0.0.1/test/index ---- get
 */
@GetMapping("/index")
public String testIndexPage(ModelMap modelMap) {
    List<City> cities = cityService.getCitiesByCountryId(522);
    City city = cityService.getCityByCityId(2255);
    modelMap.put("userName", "HymanHu");
    modelMap.put("current1", new Date());
    modelMap.put("current2", LocalDateTime.now());
    modelMap.put("number", 23.453);
    modelMap.put("age", 18);
    modelMap.put("cities", cities.stream().limit(10).collect(Collectors.toList()));
    modelMap.put("city", city);
    return "test/index";
}
/**
 * 127.0.0.1/test/city ---- put
 */
@PutMapping(value = "/city", consumes = "application/x-www-form-urlencoded")
public String updateCityForm(@ModelAttribute City city) {
    cityService.updateCity(city);
    return "redirect:/test/index";
}

Web 应用

监听器

需求：用户登录或认证后，会将 User 对象存入 Session，做一个监听器，统计在线用户总人数，并以日志的方式输出登录用户的相关信息；
OnlineUserCounterListener.java

在此我们实现了三个监听器，作用分别是：

HttpSessionListener：监听 HttpSession 被创建，无效或超；
HttpSessionAttributesListener：监听 HttpSession 属性 added、removed 或 replaced 事件；
ServletRequestListener：获取 HttpServletRequest 对象；

@WebListener
public class OnlineUserCounterListener implements HttpSessionListener, 
    HttpSessionAttributeListener, ServletRequestListener {
    
    private final static Logger LOGGER = LogManager.getLogger(OnlineUserCounterListener.class);
    private static ThreadLocal<HttpServletRequest> httpServletRequestHolder = new ThreadLocal<HttpServletRequest>();

// Session 创建时，输出 Session id
    @Override
    public void sessionCreated(HttpSessionEvent se) {
        LOGGER.debug(String.format("New session id: %s", se.getSession().getId()));
    }

// Session 销毁时候，计数器减一
    @Override
    public void sessionDestroyed(HttpSessionEvent se) {
        ServletContext servletContext = se.getSession().getServletContext();
        Integer count = servletContext.getAttribute("onlineUserCounter") == null ? 
                0 : (Integer) servletContext.getAttribute("onlineUserCounter");
        count --;
        servletContext.setAttribute("onlineUserCounter", count);
    }

// Session 添加 user，计数器加一，并输出用户登录信息
    @Override
    public void attributeAdded(HttpSessionBindingEvent se) {
        ServletContext servletContext = se.getSession().getServletContext();
        
        Integer count = servletContext.getAttribute("onlineUserCounter") == null ? 
                0 : (Integer) servletContext.getAttribute("onlineUserCounter");
        if ("user".equals(se.getName())) {
            count ++;
            servletContext.setAttribute("onlineUserCounter", count);
            User user = (User) se.getSession().getAttribute("user");
            /*
             * -因为 Listener 是由 Servlet 负责实例化，如果直接注入 RoleService，
             * -拿不到 Spring 容器的 Bean，因此使用 WebApplicationContextUtils
             */
            RoleService roleService = 
                    WebApplicationContextUtils.getWebApplicationContext(servletContext).getBean(RoleService.class);
            List<Role> roles = roleService.getRolesByUserId(user.getId());
            HttpServletRequest httpServletRequest = httpServletRequestHolder.get();
            LOGGER.debug(String.format("Online user count: %s", count));
            LOGGER.debug(String.format("Login user name: %s", user.getUserName()));
            LOGGER.debug(String.format("Login user roles: %s", 
                    roles.stream().map(item -> item.getRoleName()).collect(Collectors.toList())));
            LOGGER.debug(String.format("Login user ip: %s", httpServletRequest.getRemoteAddr()));
            LOGGER.debug(String.format("Login date time: %s", 
                    DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss").format(LocalDateTime.now())));
        }
        
    }

// Session 移除 user，计数器减一
    @Override
    public void attributeRemoved(HttpSessionBindingEvent se) {
        ServletContext servletContext = se.getSession().getServletContext();
        Integer count = servletContext.getAttribute("onlineUserCounter") == null ? 
                0 : (Integer) servletContext.getAttribute("onlineUserCounter");
        if ("user".equals(se.getName())) {
            count --;
            servletContext.setAttribute("onlineUserCounter", count);
        }
    }

@Override
    public void attributeReplaced(HttpSessionBindingEvent se) {
    }

@Override
    public void requestInitialized(ServletRequestEvent sre) {
        httpServletRequestHolder.set((HttpServletRequest)sre.getServletRequest());
    }
    
    @Override
    public void requestDestroyed(ServletRequestEvent sre) {
        httpServletRequestHolder.remove();
    }
}

 
@WebListener
public class OnlineUserCounterListener implements HttpSessionListener, 
    HttpSessionAttributeListener, ServletRequestListener {
    
    private final static Logger LOGGER = LogManager.getLogger(OnlineUserCounterListener.class);
    private static ThreadLocal<HttpServletRequest> httpServletRequestHolder = new ThreadLocal<HttpServletRequest>();
    // Session 创建时，输出 Session id
    @Override
    public void sessionCreated(HttpSessionEvent se) {
        LOGGER.debug(String.format("New session id: %s", se.getSession().getId()));
    }
    // Session 销毁时候，计数器减一
    @Override
    public void sessionDestroyed(HttpSessionEvent se) {
        ServletContext servletContext = se.getSession().getServletContext();
        Integer count = servletContext.getAttribute("onlineUserCounter") == null ? 
                0 : (Integer) servletContext.getAttribute("onlineUserCounter");
        count --;
        servletContext.setAttribute("onlineUserCounter", count);
    }
    // Session 添加 user，计数器加一，并输出用户登录信息
    @Override
    public void attributeAdded(HttpSessionBindingEvent se) {
        ServletContext servletContext = se.getSession().getServletContext();
        
        Integer count = servletContext.getAttribute("onlineUserCounter") == null ? 
                0 : (Integer) servletContext.getAttribute("onlineUserCounter");
        if ("user".equals(se.getName())) {
            count ++;
            servletContext.setAttribute("onlineUserCounter", count);
            User user = (User) se.getSession().getAttribute("user");
            /*
             * -因为 Listener 是由 Servlet 负责实例化，如果直接注入 RoleService，
             * -拿不到 Spring 容器的 Bean，因此使用 WebApplicationContextUtils
             */
            RoleService roleService = 
                    WebApplicationContextUtils.getWebApplicationContext(servletContext).getBean(RoleService.class);
            List<Role> roles = roleService.getRolesByUserId(user.getId());
            HttpServletRequest httpServletRequest = httpServletRequestHolder.get();
            LOGGER.debug(String.format("Online user count: %s", count));
            LOGGER.debug(String.format("Login user name: %s", user.getUserName()));
            LOGGER.debug(String.format("Login user roles: %s", 
                    roles.stream().map(item -> item.getRoleName()).collect(Collectors.toList())));
            LOGGER.debug(String.format("Login user ip: %s", httpServletRequest.getRemoteAddr()));
            LOGGER.debug(String.format("Login date time: %s", 
                    DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss").format(LocalDateTime.now())));
        }
        
    }
    // Session 移除 user，计数器减一
    @Override
    public void attributeRemoved(HttpSessionBindingEvent se) {
        ServletContext servletContext = se.getSession().getServletContext();
        Integer count = servletContext.getAttribute("onlineUserCounter") == null ? 
                0 : (Integer) servletContext.getAttribute("onlineUserCounter");
        if ("user".equals(se.getName())) {
            count --;
            servletContext.setAttribute("onlineUserCounter", count);
        }
    }
    @Override
    public void attributeReplaced(HttpSessionBindingEvent se) {
    }
    @Override
    public void requestInitialized(ServletRequestEvent sre) {
        httpServletRequestHolder.set((HttpServletRequest)sre.getServletRequest());
    }
    
    @Override
    public void requestDestroyed(ServletRequestEvent sre) {
        httpServletRequestHolder.remove();
    }
}

注册监听器

web.xml 注册 || @WebListener 注册，在此我们采用 @WebListener 的方式；
Listener 是由 Servlet 负责实例化，无法直接获取 Spring 容器的 Bean，无法直接 @Autowired，在此我们采用 WebApplicationContextUtils 来获取；

运行

过滤器

需求：允许用户使用 Basic 模式进行用户验证，即在 HTTP 请求中添加头 Authorization: Basic userName:password 信息，过滤器中解析出 userName 和 password，查询数据库验证，并将 User 放入Session；
AuthFilter.java

实现 javax.servlet.Filter 或者继承 Spring Mvc 已经给我们写好的过滤器，重写 doFilter 方法实现业务逻辑，最后需要调用 chain.doFilter(req, resp); 将请求和响应交出去；

@Component
public class AuthFilter implements Filter {
    
    private final static Logger LOGGER = LogManager.getLogger(AuthFilter.class);
    @Autowired
    private UserService userService;

/**
     * Authorization: Basic userName:password
     */
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        HttpServletRequest req = (HttpServletRequest)request;
        HttpServletResponse resp = (HttpServletResponse) response;
        LOGGER.debug("RequestUri: " + req.getRequestURI());
        
        String authHeader = req.getHeader("Authorization");
        if (StringUtils.isNotBlank(authHeader) && authHeader.startsWith("Basic ")) {
            String userNameAndPassword = authHeader.substring(authHeader.indexOf(" ") + 1);
            String userName = userNameAndPassword.split(":")[0];
            String password = userNameAndPassword.split(":")[1];
            LOGGER.debug(String.format("Request header Auth:%s - %s", userName, password));
            
            User user = userService.getUserByUserNameAndPassword(userName, password);
            if (user != null) {
                LOGGER.debug(String.format("User %s is auth success.", user.getUserName()));
                req.getSession().setAttribute("user", user);
            }
        }
        chain.doFilter(req, resp);
    }
}

 
@Component
public class AuthFilter implements Filter {
    
    private final static Logger LOGGER = LogManager.getLogger(AuthFilter.class);
    @Autowired
    private UserService userService;
    /**
     * Authorization: Basic userName:password
     */
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        HttpServletRequest req = (HttpServletRequest)request;
        HttpServletResponse resp = (HttpServletResponse) response;
        LOGGER.debug("RequestUri: " + req.getRequestURI());
        
        String authHeader = req.getHeader("Authorization");
        if (StringUtils.isNotBlank(authHeader) && authHeader.startsWith("Basic ")) {
            String userNameAndPassword = authHeader.substring(authHeader.indexOf(" ") + 1);
            String userName = userNameAndPassword.split(":")[0];
            String password = userNameAndPassword.split(":")[1];
            LOGGER.debug(String.format("Request header Auth:%s - %s", userName, password));
            
            User user = userService.getUserByUserNameAndPassword(userName, password);
            if (user != null) {
                LOGGER.debug(String.format("User %s is auth success.", user.getUserName()));
                req.getSession().setAttribute("user", user);
            }
        }
        chain.doFilter(req, resp);
    }
}

注册过滤器

web.xml 注册 || @WebFilter 注解注册，在此我们采用 web.xml 注册；
web.xml 中已经配置了几个过滤器：Log4jServletFilter、CharacterEncodingFilter、HttpPutFormContentFilter、HiddenHttpMethodFilter，我们可按此规则注册自定义过滤器；

1
<filter> <filter-name>authFilter</filter-name> <filter-class>com.sfac.springMvc.filter.AuthFilter</filter-class> </filter> <filter-mapping> <filter-name>authFilter</filter-name> <url-pattern>/*</url-pattern> </filter-mapping>
1
<filter>
2
<filter-name>authFilter</filter-name>
3
<filter-class>com.sfac.springMvc.filter.AuthFilter</filter-class>
4
</filter>
5
<filter-mapping>
6
<filter-name>authFilter</filter-name>
7
<url-pattern>/*</url-pattern>
8
</filter-mapping>
2

启动项目调试发现，过滤器中注入的 UserService 为 null，虽然使用了 @Component 注解，但 Spring 容器创建的这个 AuthFilter 是一个普通 Bean，Servlet 容器并不知道，如果我们按上面的方式注册过滤器，AuthFilter 将由 Servlet 创建，因此在 AuthFilter 中注入的 Spring Bean 为 null，所以，我们得通过一种方式，让 Servlet 容器实例化 AuthFilter 时，间接引用 Spring 容器实例化的 AuthFilter，Spring MVC 提供了一个 DelegatingFilterProxy，专门来干这个事情；

1
<filter> <filter-name>authFilter</filter-name> <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class> </filter> <filter-mapping> <filter-name>authFilter</filter-name> <url-pattern>/*</url-pattern> </filter-mapping>
1
<filter>
2
<filter-name>authFilter</filter-name>
3
<filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
4
</filter>
5
<filter-mapping>
6
<filter-name>authFilter</filter-name>
7
<url-pattern>/*</url-pattern>
8
</filter-mapping>
2
Servlet 容器从 web.xml 中实例化 DelegatingFilterProxy，注意命名是 authFilter；
Spring 容器通过扫描 @Component 实例化 AuthFilter；
当 DelegatingFilterProxy 生效后，它会自动查找注册在 ServletContext 上的 Spring 容器，再试图从容器中查找名为 authFilter 的 Bean，也就是我们用 @Component 声明的 AuthFilter；
DelegatingFilterProxy 将请求代理给 AuthFilter，源码如下：

拦截器

简介：在业务流中增强某些功能，比如日志记录、权限检查、性能监控、Session 和 Cookie 处理等；
需求：记录请求信息以及控制器的运行时间；
ControllerMonitorInterceptor.java

@Component
public class ControllerMonitorInterceptor extends HandlerInterceptorAdapter {
    
    private final static Logger LOGGER = LogManager.getLogger(AuthFilter.class);
    private static ThreadLocal<Long> threadLocal = new ThreadLocal<Long>();

@Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        LOGGER.debug("======== Pre Interceptor ========");
        long startTime = System.currentTimeMillis();
        threadLocal.set(startTime);
        return true;
    }

@Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
            ModelAndView modelAndView) throws Exception {
        LOGGER.debug(String.format("Request uri: %s", request.getRequestURI()));
        LOGGER.debug(String.format("Request method: %s", request.getMethod()));
        LOGGER.debug(String.format("Request remote address: %s", request.getRemoteAddr()));
    }

@Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
            throws Exception {
        long endTime = System.currentTimeMillis();
        long startTime = threadLocal.get();
        LOGGER.debug(String.format("Elapse time: %s millisecond", (endTime - startTime)));
        LOGGER.debug("======== After Interceptor ========");
    }
}

 
@Component
public class ControllerMonitorInterceptor extends HandlerInterceptorAdapter {
    
    private final static Logger LOGGER = LogManager.getLogger(AuthFilter.class);
    private static ThreadLocal<Long> threadLocal = new ThreadLocal<Long>();
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        LOGGER.debug("======== Pre Interceptor ========");
        long startTime = System.currentTimeMillis();
        threadLocal.set(startTime);
        return true;
    }
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
            ModelAndView modelAndView) throws Exception {
        LOGGER.debug(String.format("Request uri: %s", request.getRequestURI()));
        LOGGER.debug(String.format("Request method: %s", request.getMethod()));
        LOGGER.debug(String.format("Request remote address: %s", request.getRemoteAddr()));
    }
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
            throws Exception {
        long endTime = System.currentTimeMillis();
        long startTime = threadLocal.get();
        LOGGER.debug(String.format("Elapse time: %s millisecond", (endTime - startTime)));
        LOGGER.debug("======== After Interceptor ========");
    }
}

注册拦截器

springMvcConfig.xml

 
<!-- 注册拦截器，可注册多个 -->
<mvc:interceptors>
    <mvc:interceptor>
        <mvc:mapping path="/**" />
        <bean id="controllerMonitorInterceptor" class="com.sfac.springMvc.interceptor.ControllerMonitorInterceptor"></bean>
    </mvc:interceptor>
</mvc:interceptors>

运行

拦截器 VS 过滤器

拦截器是基于 Java 的反射机制，使用代理模式，而过滤器是基于函数回调；
拦截器不依赖 Servlet 容器，过滤器依赖于 Servlet 容器；
拦截器只能对 Action（也就是 Controller）请求起作用，而过滤器则可以对几乎所有的请求起作用；
拦截器可以获取 IOC 容器中的各个 Bean，而过滤器需要特殊处理才可以；
执行顺序：过滤前 ---- 拦截前 ---- Action 处理 ---- 拦截后 ---- 过滤后；

AOP 切面编程

参见 Spring AOP 章节内容；

异常统一处理

需求

在 Controller 层统一处理异常；
将异常信息记录到数据库；
调用方法如果是接口，返回包含异常信息的 Json 数据；调用方法如果返回页面，则重定向到错误页面；

实现步骤

common.entity 包下创建 ExceptionLog.java，自行添加 get/set 方法；

 
@Entity
@Table(name = "common_exception_log")
public class ExceptionLog extends AbstractEntity {
    private String ip;
    private String path;
    private String className;
    private String methodName;
    private String exceptionType;
    private String exceptionMessage;
}

创建 ExceptionLogDao.java、ExceptionLogService.java，为 ExceptionLog 提供 Dao 层和 Service 层，用于存储异常信息；
在 templates/common 文件夹下创建 500.jsp 页面，移植前端模版错误页面；
CommonController.java 控制器中添加方法，返回 500 错误页面；
在 interceptor 包下创建 SpringMvcHandlerExceptionResolver.java，将异常的统一处理看做特殊的拦截器；

@Component
public class SpringMvcHandlerExceptionResolver implements HandlerExceptionResolver {
    
    private final static Logger LOGGER = LogManager.getLogger(SpringMvcHandlerExceptionResolver.class);
    @Autowired
    private ExceptionLogService exceptionLogService;

@Override
    public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, 
            Object handler, Exception ex) {
        ex.printStackTrace();
        if (handler instanceof HandlerMethod) {
            LOGGER.debug("======== Log exception into db ========");
            String ip = IPUtils.getIpAddr(request);
            HandlerMethod handlerMethod = (HandlerMethod) handler;
            String className = handlerMethod.getBeanType().getName();
            String methodName = handlerMethod.getMethod().getName();
            String exceptionType = ex.getClass().getSimpleName();
            String exceptionMessage = ex.getMessage();
            
            ExceptionLog exceptionLog = new ExceptionLog();
            exceptionLog.setIp(ip);
            exceptionLog.setPath(request.getServletPath());
            exceptionLog.setClassName(className);
            exceptionLog.setMethodName(methodName);
            exceptionLog.setExceptionType(exceptionType);
            exceptionLog.setExceptionMessage(exceptionMessage);
            exceptionLog.setCreateDate(LocalDateTime.now());
            
            exceptionLogService.insertExceptionLog(exceptionLog);
            
            if (isInterface(handlerMethod)) {
                return jsonResult(ResultEntity.ResultStatus.FAILED.status, exceptionMessage);
            } else {
                return pageResult("common/500", exceptionMessage);
            }
        }
        return null;
    }
    
    // 判断目标方法是否为接口
    private boolean isInterface(HandlerMethod handlerMethod) {
        Annotation[] classAnnotations = handlerMethod.getBeanType().getAnnotationsByType(RestController.class);
        Annotation[] methodAnnotations = handlerMethod.getMethod().getAnnotationsByType(ResponseBody.class);
        return (classAnnotations.length > 0) || (methodAnnotations.length > 0);
    }
    
    // 判断是否是 Ajax 请求
    private boolean isAjax(HttpServletRequest request) {
        return "XMLHttpRequest".equalsIgnoreCase(request.getHeader("X-Requested-With"));
    }
    
    // 返回页面
    private ModelAndView pageResult(String url, String message) {
        Map<String, String> model = new HashMap<String, String>();
        model.put("message", message);
        // 直接返回页面
        //return new ModelAndView(url, model);
        // 重定向到错误页面控制器
        return new ModelAndView("redirect:/common/500", model);
    }
    
    // 返回 Json 数据
    private ModelAndView jsonResult(int status, String message) {
        ModelAndView mv = new ModelAndView(new MappingJackson2JsonView());
        mv.addObject("status", status);
        mv.addObject("message", message);
        return mv;
    }
}

 
@Component
public class SpringMvcHandlerExceptionResolver implements HandlerExceptionResolver {
    
    private final static Logger LOGGER = LogManager.getLogger(SpringMvcHandlerExceptionResolver.class);
    @Autowired
    private ExceptionLogService exceptionLogService;
    @Override
    public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, 
            Object handler, Exception ex) {
        ex.printStackTrace();
        if (handler instanceof HandlerMethod) {
            LOGGER.debug("======== Log exception into db ========");
            String ip = IPUtils.getIpAddr(request);
            HandlerMethod handlerMethod = (HandlerMethod) handler;
            String className = handlerMethod.getBeanType().getName();
            String methodName = handlerMethod.getMethod().getName();
            String exceptionType = ex.getClass().getSimpleName();
            String exceptionMessage = ex.getMessage();
            
            ExceptionLog exceptionLog = new ExceptionLog();
            exceptionLog.setIp(ip);
            exceptionLog.setPath(request.getServletPath());
            exceptionLog.setClassName(className);
            exceptionLog.setMethodName(methodName);
            exceptionLog.setExceptionType(exceptionType);
            exceptionLog.setExceptionMessage(exceptionMessage);
            exceptionLog.setCreateDate(LocalDateTime.now());
            
            exceptionLogService.insertExceptionLog(exceptionLog);
            
            if (isInterface(handlerMethod)) {
                return jsonResult(ResultEntity.ResultStatus.FAILED.status, exceptionMessage);
            } else {
                return pageResult("common/500", exceptionMessage);
            }
        }
        return null;
    }
    
    // 判断目标方法是否为接口
    private boolean isInterface(HandlerMethod handlerMethod) {
        Annotation[] classAnnotations = handlerMethod.getBeanType().getAnnotationsByType(RestController.class);
        Annotation[] methodAnnotations = handlerMethod.getMethod().getAnnotationsByType(ResponseBody.class);
        return (classAnnotations.length > 0) || (methodAnnotations.length > 0);
    }
    
    // 判断是否是 Ajax 请求
    private boolean isAjax(HttpServletRequest request) {
        return "XMLHttpRequest".equalsIgnoreCase(request.getHeader("X-Requested-With"));
    }
    
    // 返回页面
    private ModelAndView pageResult(String url, String message) {
        Map<String, String> model = new HashMap<String, String>();
        model.put("message", message);
        // 直接返回页面
        //return new ModelAndView(url, model);
        // 重定向到错误页面控制器
        return new ModelAndView("redirect:/common/500", model);
    }
    
    // 返回 Json 数据
    private ModelAndView jsonResult(int status, String message) {
        ModelAndView mv = new ModelAndView(new MappingJackson2JsonView());
        mv.addObject("status", status);
        mv.addObject("message", message);
        return mv;
    }
}

测试：启动项目，调用有异常的接口，查看是否按照我们的意图返回，查看数据库是否存入异常信息；

文件上传

简介：Spring Mvc 对 Apache FileUpload 组件进行了封装，由 MultipartFile 接口来实现文件上传；
pom 导入 jar

commons-fileupload、commons-io（自动导入）；

 
<!-- Spring Mvc 文件上传 -->
<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.4</version>
</dependency>

springMvcConfig.xml 配置

 
<!-- 上传文件 -->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <!-- 1TB=1024GB,1GB=1024MB,1MB=1024KB,1KB=1024Byte,1Byte=8bit -->
    <!-- 此处配置数值的单位是Byte，设置上传文件的最大尺寸为 10M：10*1024*1024 -->
    <property name="maxUploadSize" value="10485760"></property>
    <property name="defaultEncoding" value="UTF-8"></property>
</bean>

test/index.jsp

 
<p>==================================================================</p>
<h3>File Upload</h3>
<p>${message}</p>
<img src="${relativePath }" width="200px;" height="200px;">
<p>上传文件，使用multipart/form-data类型</p>
<form action="/test/file" method="post" enctype="multipart/form-data">
    <input type="file" name="file">
    <button type="submit">上传</button>
</form>
<form action="/test/files" method="post" enctype="multipart/form-data">
    <input type="file" name="files">
    <input type="file" name="files">
    <button type="submit">上传</button>
</form>
<p>==================================================================</p>

TestController.java

@Autowired
private ResourceConfigBean resourceConfigBean;
/**
 * 127.0.0.1/test/file ---- post
 */
//@PostMapping(value = "/file", consumes = "multipart/form-data")
@PostMapping(value = "/file", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
public String uploadFile(@RequestParam MultipartFile file, 
		RedirectAttributes redirectAttributes) {
	if (file.isEmpty()) {
		redirectAttributes.addFlashAttribute("message", "Please select file");
		return "redirect:/test/index";
	}
	
	String absolutePath = resourceConfigBean.getLocalPathForWindow() + file.getOriginalFilename();
	String relativePath = resourceConfigBean.getResourcePath() + file.getOriginalFilename();
	try {
		File destFile = new File(absolutePath);
		file.transferTo(destFile);
		
		// 使用工具类 Files 来上传文件
//			byte[] bytes = file.getBytes();
//			Path path = Paths.get(absolutePath);
//			Files.write(path, bytes);
	
	} catch (IllegalStateException | IOException e) {
		e.printStackTrace();
		redirectAttributes.addFlashAttribute("message", "Upload fail.");
		return "redirect:/test/index";
	}
	
	redirectAttributes.addFlashAttribute("message", "Upload success.");
	redirectAttributes.addFlashAttribute("relativePath", relativePath);
	
	return "redirect:/test/index";
}

/**
 * 127.0.0.1/test/files ---- post
 */
@PostMapping(value="/files", consumes="multipart/form-data")
public String uploadFiles(@RequestParam MultipartFile[] files, 
		RedirectAttributes redirectAttributes) {
	boolean isEmpty = true;
	
	try {
		for (MultipartFile file : files) {
			if (file.isEmpty()) {
				continue;
			}
			
			String fileName = file.getOriginalFilename();
			String destFilePath = resourceConfigBean.getLocalPathForWindow() + fileName;
			File destFile = new File(destFilePath);
			file.transferTo(destFile);
			
			isEmpty = false;
		}
	} catch (IllegalStateException | IOException e) {
		e.printStackTrace();
		redirectAttributes.addFlashAttribute("message", "Upload file failed.");
		return "redirect:/test/index";
	}
	
	if (isEmpty) {
		redirectAttributes.addFlashAttribute("message", "Please select file.");
	} else {
		redirectAttributes.addFlashAttribute("message", "Upload file success.");
	}
	return "redirect:/test/index";
}

 
@Autowired
private ResourceConfigBean resourceConfigBean;
/**
 * 127.0.0.1/test/file ---- post
 */
//@PostMapping(value = "/file", consumes = "multipart/form-data")
@PostMapping(value = "/file", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
public String uploadFile(@RequestParam MultipartFile file, 
        RedirectAttributes redirectAttributes) {
    if (file.isEmpty()) {
        redirectAttributes.addFlashAttribute("message", "Please select file");
        return "redirect:/test/index";
    }
    
    String absolutePath = resourceConfigBean.getLocalPathForWindow() + file.getOriginalFilename();
    String relativePath = resourceConfigBean.getResourcePath() + file.getOriginalFilename();
    try {
        File destFile = new File(absolutePath);
        file.transferTo(destFile);
        
        // 使用工具类 Files 来上传文件
//          byte[] bytes = file.getBytes();
//          Path path = Paths.get(absolutePath);
//          Files.write(path, bytes);
    
    } catch (IllegalStateException | IOException e) {
        e.printStackTrace();
        redirectAttributes.addFlashAttribute("message", "Upload fail.");
        return "redirect:/test/index";
    }
    
    redirectAttributes.addFlashAttribute("message", "Upload success.");
    redirectAttributes.addFlashAttribute("relativePath", relativePath);
    
    return "redirect:/test/index";
}
/**
 * 127.0.0.1/test/files ---- post
 */
@PostMapping(value="/files", consumes="multipart/form-data")
public String uploadFiles(@RequestParam MultipartFile[] files, 
        RedirectAttributes redirectAttributes) {
    boolean isEmpty = true;
    
    try {
        for (MultipartFile file : files) {
            if (file.isEmpty()) {
                continue;
            }
            
            String fileName = file.getOriginalFilename();
            String destFilePath = resourceConfigBean.getLocalPathForWindow() + fileName;
            File destFile = new File(destFilePath);
            file.transferTo(destFile);
            
            isEmpty = false;
        }
    } catch (IllegalStateException | IOException e) {
        e.printStackTrace();
        redirectAttributes.addFlashAttribute("message", "Upload file failed.");
        return "redirect:/test/index";
    }
    
    if (isEmpty) {
        redirectAttributes.addFlashAttribute("message", "Please select file.");
    } else {
        redirectAttributes.addFlashAttribute("message", "Upload file success.");
    }
    return "redirect:/test/index";
}

文件下载

/text/index.jsp

1
<p>==================================================================</p> <h3>File Download</h3> <p><a href="/test/file3?fileName=11.jpg">download file</a></p> <p>==================================================================</p>
1
<p>==================================================================</p>
2
<h3>File Download</h3>
3
<p><a href="/test/file3?fileName=11.jpg">download file</a></p>
4
<p>==================================================================</p>
2

TestController.java

/**
 * 127.0.0.1/test/file1?fileName=***.jpg ---- get
 */
@RequestMapping("/file1")
public void downloadFile1(HttpServletRequest request, 
		HttpServletResponse response, @RequestParam String fileName) {
	String filePath = resourceConfigBean.getLocalPathForWindow() + fileName;
	File downloadFile = new File(filePath);
	
	if (downloadFile.exists()) {
		response.setContentType("application/octet-stream");
		response.setContentLength((int)downloadFile.length());
		response.setHeader(HttpHeaders.CONTENT_DISPOSITION, 
				String.format("attachment; filename=\"%s\"", fileName));
		
		byte[] buffer = new byte[1024];
		FileInputStream fis = null;
		BufferedInputStream bis = null;
		try {
			fis = new FileInputStream(downloadFile);
			bis = new BufferedInputStream(fis);
			OutputStream os = response.getOutputStream();
			int i = 0;
			while ((i = bis.read(buffer)) != -1) {
				os.write(buffer, 0, i);
			}
		} catch (Exception e) {
			LOGGER.debug(e.getMessage());
			e.printStackTrace();
		} finally {
			try {
				if (fis != null) {
					fis.close();
				}
				if (bis != null) {
					bis.close();
				}
			} catch (Exception e2) {
				LOGGER.debug(e2.getMessage());
				e2.printStackTrace();
			}
		}
	}
}

/**
 * 127.0.0.1/test/file2?fileName=***.jpg ---- get
 */
@RequestMapping("/file2")
public void downloadFile2(HttpServletRequest request, 
		HttpServletResponse response, @RequestParam String fileName) {
	String filePath = resourceConfigBean.getLocalPathForWindow() + fileName;
	File downloadFile = new File(filePath);
	
	try {
		if (downloadFile.exists()) {
			response.setContentType("application/octet-stream");
			response.setContentLength((int)downloadFile.length());
			response.setHeader(HttpHeaders.CONTENT_DISPOSITION, 
					String.format("attachment; filename=\"%s\"", fileName));
			
			InputStream is = new FileInputStream(downloadFile);
			IOUtils.copy(is, response.getOutputStream());
			response.flushBuffer();
		}
	} catch (Exception e) {
		LOGGER.debug(e.getMessage());
		e.printStackTrace();
	}
}

/**
 * 127.0.0.1/test/file3?fileName=***.jpg ---- get
 */
@RequestMapping("/file3")
public ResponseEntity<Resource> downLoadFile(@RequestParam String fileName) {
	try {
		Resource resource = new UrlResource(Paths.get(
				resourceConfigBean.getLocalPathForWindow() + fileName).toUri());
		
		return ResponseEntity.ok()
				.header(HttpHeaders.CONTENT_TYPE, "application/octet-stream")
				.header(HttpHeaders.CONTENT_DISPOSITION, 
						String.format("attachment; filename=\"%s\"", resource.getFilename()))
				.body(resource);
	} catch (Exception e) {
		e.printStackTrace();
	}
	
	return null;
}

 
/**
 * 127.0.0.1/test/file1?fileName=***.jpg ---- get
 */
@RequestMapping("/file1")
public void downloadFile1(HttpServletRequest request, 
        HttpServletResponse response, @RequestParam String fileName) {
    String filePath = resourceConfigBean.getLocalPathForWindow() + fileName;
    File downloadFile = new File(filePath);
    
    if (downloadFile.exists()) {
        response.setContentType("application/octet-stream");
        response.setContentLength((int)downloadFile.length());
        response.setHeader(HttpHeaders.CONTENT_DISPOSITION, 
                String.format("attachment; filename=\"%s\"", fileName));
        
        byte[] buffer = new byte[1024];
        FileInputStream fis = null;
        BufferedInputStream bis = null;
        try {
            fis = new FileInputStream(downloadFile);
            bis = new BufferedInputStream(fis);
            OutputStream os = response.getOutputStream();
            int i = 0;
            while ((i = bis.read(buffer)) != -1) {
                os.write(buffer, 0, i);
            }
        } catch (Exception e) {
            LOGGER.debug(e.getMessage());
            e.printStackTrace();
        } finally {
            try {
                if (fis != null) {
                    fis.close();
                }
                if (bis != null) {
                    bis.close();
                }
            } catch (Exception e2) {
                LOGGER.debug(e2.getMessage());
                e2.printStackTrace();
            }
        }
    }
}
/**
 * 127.0.0.1/test/file2?fileName=***.jpg ---- get
 */
@RequestMapping("/file2")
public void downloadFile2(HttpServletRequest request, 
        HttpServletResponse response, @RequestParam String fileName) {
    String filePath = resourceConfigBean.getLocalPathForWindow() + fileName;
    File downloadFile = new File(filePath);
    
    try {
        if (downloadFile.exists()) {
            response.setContentType("application/octet-stream");
            response.setContentLength((int)downloadFile.length());
            response.setHeader(HttpHeaders.CONTENT_DISPOSITION, 
                    String.format("attachment; filename=\"%s\"", fileName));
            
            InputStream is = new FileInputStream(downloadFile);
            IOUtils.copy(is, response.getOutputStream());
            response.flushBuffer();
        }
    } catch (Exception e) {
        LOGGER.debug(e.getMessage());
        e.printStackTrace();
    }
}
/**
 * 127.0.0.1/test/file3?fileName=***.jpg ---- get
 */
@RequestMapping("/file3")
public ResponseEntity<Resource> downLoadFile(@RequestParam String fileName) {
    try {
        Resource resource = new UrlResource(Paths.get(
                resourceConfigBean.getLocalPathForWindow() + fileName).toUri());
        
        return ResponseEntity.ok()
                .header(HttpHeaders.CONTENT_TYPE, "application/octet-stream")
                .header(HttpHeaders.CONTENT_DISPOSITION, 
                        String.format("attachment; filename=\"%s\"", resource.getFilename()))
                .body(resource);
    } catch (Exception e) {
        e.printStackTrace();
    }
    
    return null;
}

国际化

springMvcConfig.xml

<bean id="localeResolver" class="org.springframework.web.servlet.i18n.SessionLocaleResolver">
	<property name="defaultLocale" value="zh_CN" />
</bean>

<bean id="messageSource" class="org.springframework.context.support.ReloadableResourceBundleMessageSource">
	<property name="defaultEncoding" value="UTF-8" />
	<property name="useCodeAsDefaultMessage" value="true" />
	
	<property name="basenames">
		<list>
			<value>classpath:i18n/language</value>
		</list>
	</property>
</bean>

<mvc:interceptors>
	<bean id="localeChangeInterceptor"
		class="org.springframework.web.servlet.i18n.LocaleChangeInterceptor">
		<property name="paramName" value="lang" />
	</bean>
</mvc:interceptors>

 
<!-- 国际化配置 -->
<!-- 
    设置国际化解析器，将 Locale 对象存储于 Session 中供后续使用
    localeResolver 名字不能变更 
-->
<bean id="localeResolver" class="org.springframework.web.servlet.i18n.SessionLocaleResolver">
    <property name="defaultLocale" value="zh_CN" />
</bean>
<!-- 
    messageSource：配置国际化资源文件的路径
    basenames | basename：classpath:i18n/language 下国际化文件
        文件格式：***_语言_国家.properties：language_zh_CN.properties、language_en_US.properties
    useCodeAsDefaultMessage：true，当 Spring 在 ResourceBundle 中找不到 messageKey 的话，
        不抛出 NoSuchMessageException，而是返回 messageKey
 -->
<bean id="messageSource" class="org.springframework.context.support.ReloadableResourceBundleMessageSource">
    <property name="defaultEncoding" value="UTF-8" />
    <property name="useCodeAsDefaultMessage" value="true" />
    <!-- <property name="basename" value="classpath:i18n/language" /> -->
    <property name="basenames">
        <list>
            <value>classpath:i18n/language</value>
        </list>
    </property>
</bean>
<!-- 该拦截器通过请求参数 lang 来拦截 Http 请求，使其重新设置页面的区域化信息 -->
<mvc:interceptors>
    <bean id="localeChangeInterceptor"
        class="org.springframework.web.servlet.i18n.LocaleChangeInterceptor">
        <property name="paramName" value="lang" />
    </bean>
</mvc:interceptors>

src/main/resources/i18n

language_en_US.properties

title = BEGIN TO START
userName = UserName
password = PassWord
login = Login

language_zh_CN.properties

title = I18N 页面
userName = 用户名
password = 密码
login = 登录

i18nLogin.jsp

 
<%@ taglib uri="http://www.springframework.org/tags" prefix="spring"%>
当前语言: ${pageContext.response.locale }
<input
    type="text"
    class="form-control"
    name="userName"
    placeholder=<spring:message code="userName" />
/>
<span class="bigger-110"><spring:message code="login" /></span>

AccountController.java

1
/** * 127.0.0.1/i18nLogin?lang=zh_CN * 127.0.0.1/i18nLogin?lang=en_US */ @GetMapping("/i18nLogin") public String i18nLoginPage() { return "account/i18nLogin"; }
1
/**
2
* 127.0.0.1/i18nLogin?lang=zh_CN
3
* 127.0.0.1/i18nLogin?lang=en_US
4
*/
5
@GetMapping("/i18nLogin")
6
public String i18nLoginPage() {
7
return "account/i18nLogin";
8
}
2

Spring Framework

简介

Spring 结构图

IOC 容器

简介

原理

配置装配 Bean

注解装配 Bean

定制 Bean

Bean 生命周期

组件体系

循环依赖

AOP 切面编程

简介

原理

注解和参数

实现方式

源码解读

Spring 事务

事务分类

事务的传播机制

隔离级别

应用

Spring MVC

简介

搭建项目

部署项目

基础配置

三层开发

Spring ORM

简介

Mybatis

Hibernate

JPA

JSP

引入

配置

应用

Web 应用

监听器

过滤器

拦截器

AOP 切面编程

异常统一处理

文件上传

文件下载

国际化

问题收集