spring集成常用技术的配置

  使用spring集成其他技术,最基本的配置都是模板化的,比如配置视图模板引擎、数据库连接池、orm框架、缓存服务、邮件服务、rpc调用等,以spring的xml配置为例,我将这些配置过程整理出来,并不时更新,以备参考!

spring

  在普通的java工程中引入spring,只需要配置以下依赖

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

  实际开发中,如果你用了log4j等日志框架,最好排除掉spring对commons-logging的依赖,写demo就不用了

<exclusions>
	<exclusion>
		<groupId>commons-logging</groupId>
		<artifactId>commons-logging</artifactId>
	</exclusion>
</exclusions>

  建一个spring-conf.xml,放在src/main/java目录(也就是所有包和类的根目录,即classpath),内容如下

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd">

	<bean class="com.xmyself.Test" />
</beans>

  建一个Test.java类,这个类就是spring-conf.xml文件中定义的那个bean

package com.xmyself;
public class Test {
	public void test() {
		System.out.println("spring is running");
	}
}

  写带有main方法的主类

package com.xmyself;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {
	public static void main(String[] args) {
		@SuppressWarnings("resource")
		ApplicationContext context = new ClassPathXmlApplicationContext("spring-conf.xml");
		Test test = context.getBean(Test.class);
		test.test();
	}
}

  运行Main,就能看到“spring is running”输出

spring mvc

  spring mvc是配置在web工程中的,使用spring mvc也只要配置一个依赖

<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-webmvc</artifactId>
	<version>3.2.17.RELEASE</version>
</dependency>

  整一个Test.java类,这是个controller

package com.xmyself.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class Test {
	@RequestMapping("/test")
	@ResponseBody
	public String test() {
		return "spring mvc is running";
	}
}

  在src/main/resources目录下建一个spring目录,里面放一个mvc-init.xml,内容如下

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

	<context:component-scan base-package="com.xmyself.controller" />
</beans>

  这个配置文件扫描了Test.java,最后修改web.xml来加载这个配置文件

<?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" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
	version="2.5">
	<display-name>spring3mvc</display-name>

	<servlet>
		<servlet-name>spring</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>classpath*:/spring/mvc-init.xml</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
	</servlet>
	<servlet-mapping>
		<servlet-name>spring</servlet-name>
		<url-pattern>/</url-pattern>
	</servlet-mapping>
</web-app>

  初始化DispatcherServlet如果没有指定xml文件地址,spring默认去WEB-INF目录找[servlet-name]-servlet.xml,这里就是spring-servlet.xml

  启动工程,浏览器访问 http:localhost:8080/springmvc/test 就能看到返回 test 值了

freemarker模板引擎

  freemarker是一种严格遵循mvc模型的模板引擎,现在介绍它的spring mvc中的配置

  配置依赖

<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-context-support</artifactId>
	<version>3.2.17.RELEASE</version>
</dependency>
<dependency>
	<groupId>org.freemarker</groupId>
	<artifactId>freemarker</artifactId>
	<version>2.3.23</version>
</dependency>

  为什么要依赖spring-context-support?因为freemarker使用的视图解析器是由spring提供的,这个解析器就在spring-context-support的jar中

  在spring mvc的mvc-init.xml中配置freemarker

<!-- freemarker config -->
<bean id="freemarkerConfig" class="org.springframework.web.servlet.view.freemarker.FreeMarkerConfigurer">
    <property name="templateLoaderPath" value="/WEB-INF/page/" />
</bean>
<bean id="viewResolver" class="org.springframework.web.servlet.view.freemarker.FreeMarkerViewResolver">
    <property name="suffix" value=".ftl" />
    <property name="contentType" value="text/html; charset=UTF-8" />
</bean>

  配置freemarker的本质是初始化上面的两个bean,所以,你可以把这段配置写在任意的xml文件,只要spring mvc能加载就行

  在WEB-INF目录建一个page目录,里面放一个freemarker.ftl文件,内容只有一句话“freemarker page 中文乱码测试”

  最后,在控制器写一个方法

@RequestMapping("/freemarker")
public String freemarker() {
    return "freemarker";
}

  启动工程,访问 http://localhost:8080/springmvc/freemarker 就能看到“freemarker page 中文乱码测试”这句话了

thymeleaf模板引擎

  thymeleaf也是一个mvc模型的模板引擎,它的后缀是.html,所以thymeleaf模板的好处是不用渲染就能看到内容,现在spring也是推荐用thymeleaf作为spring mvc的模板引擎

  配置依赖

<dependency>
	<groupId>org.thymeleaf</groupId>
	<artifactId>thymeleaf-spring3</artifactId>
	<version>2.1.5.RELEASE</version>
</dependency>

  这是thymeleaf与spring连接用的jar,它依赖了thymeleaf的jar,对于spring3和spring4,thymeleaf的依赖是不同的,配置也稍有不同,这点要注意,下面就开始配置thymeleaf

<!-- thymeleaf config -->
<bean id="templateResolver" class="org.thymeleaf.templateresolver.ServletContextTemplateResolver">
	<property name="prefix" value="/WEB-INF/page/" />
	<property name="suffix" value=".html" />
	<property name="templateMode" value="HTML5" />
</bean>
<bean id="templateEngine" class="org.thymeleaf.spring3.SpringTemplateEngine">
	<property name="templateResolver" ref="templateResolver" />
</bean>
<bean class="org.thymeleaf.spring3.view.ThymeleafViewResolver">
	<property name="templateEngine" ref="templateEngine" />
	<property name="characterEncoding" value="UTF-8" />
</bean>

  这段配置放在spring mvc能读到的任意xml文件都可以

  在WEB-INF目录建一个page目录,里面放一个thymeleaf.html,内容只有一行“thymeleaf page 中文乱码测试”

  最后,在控制器写一个方法

@RequestMapping("/thymeleaf")
public String thymeleaf() {
    return "thymeleaf";
}

  启动工程,访问 http://localhost:8080/springmvc/thymeleaf就能看到“thymeleafpage 中文乱码测试”这句话了

tomcat pool数据库连接池

  java的数据库连接池可能用dbcp、c3p0的人多一点,但这里介绍的是tomcat pool,而且是针对mysql数据库的配置过程

  配置依赖

<dependency>
	<groupId>mysql</groupId>
	<artifactId>mysql-connector-java</artifactId>
	<version>5.1.27</version>
</dependency>
<dependency>
	<groupId>org.apache.tomcat</groupId>
	<artifactId>tomcat-jdbc</artifactId>
	<version>7.0.73</version>
</dependency>

  注意:tomcat-jdbc依赖了tomcat-juli

  下面整一个Main.java来测试连接

package com.xmyself;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import org.apache.tomcat.jdbc.pool.DataSource;
import org.apache.tomcat.jdbc.pool.PoolProperties;

public class Main {
	public static void main(String[] args) throws Exception {
		PoolProperties p = new PoolProperties();
		p.setUrl("jdbc:mysql://localhost:3306/mysql");
		p.setDriverClassName("com.mysql.jdbc.Driver");
		p.setUsername("root");
		p.setPassword("root");
		p.setJmxEnabled(true);
		p.setTestWhileIdle(false);
		p.setTestOnBorrow(true);
		p.setValidationQuery("SELECT 1");
		p.setTestOnReturn(false);
		p.setValidationInterval(30000);
		p.setTimeBetweenEvictionRunsMillis(30000);
		p.setMaxActive(100);
		p.setInitialSize(10);
		p.setMaxWait(10000);
		p.setRemoveAbandonedTimeout(60);
		p.setMinEvictableIdleTimeMillis(30000);
		p.setMinIdle(10);
		p.setLogAbandoned(true);
		p.setRemoveAbandoned(true);
		p.setJdbcInterceptors("org.apache.tomcat.jdbc.pool.interceptor.ConnectionState;"
				+ "org.apache.tomcat.jdbc.pool.interceptor.StatementFinalizer");
		DataSource datasource = new DataSource();
		datasource.setPoolProperties(p);
		Connection con = null;
		try {
			con = datasource.getConnection();
			Statement st = con.createStatement();
			ResultSet rs = st.executeQuery("select * from user");
			int cnt = 1;
			while (rs.next()) {
				System.out.println((cnt++) + ". Host:" + rs.getString("Host")
						+ " User:" + rs.getString("User") + " Password:"
						+ rs.getString("Password"));
			}
			rs.close();
			st.close();
		} finally {
			if (con != null)
				try {
					con.close();
				} catch (Exception ignore) {
				}
		}
	}
}

  这个例子是tomcat官方文档给出的,运行结果如下

1. Host:localhost User:root Password:*81F5E21E35407D884A6CD4A731AEBFB6AF209E1B
2. Host:127.0.0.1 User:root Password:*81F5E21E35407D884A6CD4A731AEBFB6AF209E1B
3. Host:::1 User:root Password:*81F5E21E35407D884A6CD4A731AEBFB6AF209E1B
4. Host:localhost User: Password:
5. Host:% User:root Password:*81F5E21E35407D884A6CD4A731AEBFB6AF209E1B

  那spring怎么集成tomcat pool呢?配置xml让spring加载就好了

<bean id="dataSource" class="org.apache.tomcat.jdbc.pool.DataSource" destroy-method="close">
	<property name="url" value="jdbc:mysql://localhost:3306/mysql" />
	<property name="driverClassName" value="com.mysql.jdbc.Driver" />
	<property name="username" value="root" />
	<property name="password" value="root" />
</bean>

  这里配置的属性与官方例子set方法中的属性完全相同,其余的我就不配置了

  然后写一个测试,这里以spring mvc为例,写一个controller,具体代码与上例相同

@Controller
public class Test {
	@Autowired
	private DataSource dataSource;

	@RequestMapping("/test")
	@ResponseBody
	public String test() throws Exception {
		Connection con = dataSource.getConnection();
		// 拿到con就可以操作了
		return "spring mvc running";
	}
}

mybatis持久化框架

  mybatis轻量级,配置简单,使用方便,我们在tomcat pool基础上来配置,当然,使用tomcat pool配置只是为了得到dataSource,如果你用dbcp、c3p0等连接池,只要修改下这个dataSource的配置就好,mybatis本身的配置不用修改

  配置依赖

<dependency>
	<groupId>org.mybatis</groupId>
	<artifactId>mybatis</artifactId>
	<version>3.4.1</version>
</dependency>

  我们定义一个TestDao.java接口,这就是mybatis要实现的东西

package com.xmyself.dao;
public interface TestDao {
	public String test();
}

  在src/main/resources目录建一个mapper目录,里面放一个TestDao.xml,内容如下

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.xmyself.dao.TestDao">
	<select id="test" resultType="java.lang.String">
		select "test"
	</select>
</mapper>

  mybatis通过一个xml文件实现了TestDao.java接口,很显然,这个实现过程肯定要用到dataSource,接下来的配置就是将TestDao.java、TestDao.xml、dataSource三者关联起来,在spring的xml配置文件(哪个配置文件没关系,只要spring能加载)添加如下内容

<bean id="dataSource" class="org.apache.tomcat.jdbc.pool.DataSource" destroy-method="close">
	<property name="url" value="jdbc:mysql://localhost:3306/mysql" />
	<property name="driverClassName" value="com.mysql.jdbc.Driver" />
	<property name="username" value="root" />
	<property name="password" value="root" />
</bean>
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
	<property name="dataSource" ref="dataSource" />
	<property name="mapperLocations" value="classpath*:mapper/*.xml" />
</bean>
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
	<property name="basePackage" value="com.xmyself.dao" />
	<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
</bean>

  这个配置我其实有点疑惑,TestDao.xml中有对TestDao.java接口的声明,所以应该只需要将dataSource与TestDao.xml做关联就够了,但实际上我没有找到这种方式

  这时候启动工程,spring加载过程会报错,其实我是故意的,^_^

Caused by: java.lang.ClassNotFoundException: org.mybatis.spring.SqlSessionFactoryBean

  因为spring内部没有直接对mybatis的支持,所以需要依赖中间层jar包,另外,还需要spring-jdbc提供对dao的支持

<dependency>
	<groupId>org.mybatis</groupId>
	<artifactId>mybatis-spring</artifactId>
	<version>1.3.0</version>
</dependency>
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-jdbc</artifactId>
	<version>3.2.17.RELEASE</version>
</dependency>

  我们整一个类来测试吧,还是以spring mvc为例,整一个controller

@Controller
public class Test {
	@Autowired
	private TestDao testDao;

	@RequestMapping("/test")
	@ResponseBody
	public String test() throws Exception {
		System.out.println(testDao.test());
		return "spring mvc is running";
	}
}

  浏览器访问 http://localhost:8080/springmvc/test 就能看到后台输出“test”

redis缓存服务

  redis是一种key-value非关系型数据库,特点是运行于内存中,速度快,作为缓存服务器非常不错,而java对redis数据库的访问是通过jedis完成的

  配置依赖

<dependency>
	<groupId>redis.clients</groupId>
	<artifactId>jedis</artifactId>
	<version>2.9.0</version>
</dependency>

  初始化jedis连接,假设redis服务器地址为:192.168.253.128,端口:6379

<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
	<property name="maxIdle" value="100" />
	<property name="maxTotal" value="300" />
	<property name="maxWaitMillis" value="1000" />
	<property name="testOnBorrow" value="true" />
</bean>
<bean id="jedisPool" class="redis.clients.jedis.JedisPool">
	<constructor-arg index="0" ref="jedisPoolConfig" />
	<constructor-arg index="1" value="192.168.253.128" type="java.lang.String" />
	<constructor-arg index="2" value="6379" type="int" />
</bean>

  这段代码放在哪没关系,只要spring能加载到,注意,构造器注入一定要指明type类型

  然后我们整一个类来测试,以spring mvc为例,整一个controller

@Controller
public class Test {
	@Autowired
	private JedisPool pool;

	@RequestMapping("/test")
	@ResponseBody
	public String test() {
		Jedis redis = pool.getResource();
		redis.set("test", "test");
		System.out.println(redis.get("test"));
		return "spring mvc is running";
	}
}

  浏览器访问 http://localhost:8080/springmvc/test,就能看到后台输出“test”

上一篇:webpack快速入门——配置JS压缩,打包


下一篇:详解intellij idea搭建SSM框架(spring+maven+mybatis+mysql+junit)(上)