使用 spring 集成其他技术,最基本的配置都是模板化的,比如配置视图模板引擎、数据库连接池、orm 框架、缓存服务、邮件服务、rpc 调用等,以 spring 的 xml 配置为例,我将这些配置过程整理出来,并不时更新,以备参考!
在普通的 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 配置完成
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 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 值了,spring mvc 配置完成
spring mvc 通常要配置模板引擎,因为 jsp 太复杂了,而且有损 mvc 模型
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 也是一个 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 中文乱码测试" 这句话了
可能用 dbcp、c3p0 连接池的人多一点,其实 tomcat pool 更好,具体怎么好请 google,下面介绍针对 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,所以如果你在 eclipse 中为工程加入了 tomcat 的库,还需要单独加一个 tomcat-juli 的 jar
下面整一个 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 轻量级,配置简单,使用方便,我们在 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 running";
- }
- }
浏览器访问 http://localhost:8080/springmvc/test 就能看到后台输出 "test",mybatis 配置完成
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 running";
- }
- }
浏览器访问 http://localhost:8080/springmvc/test,就能看到后台输出 "test",jedis 配置完成
dubbo 是阿里巴巴开源的分布式 rpc 框架,现在假设服务提供方正常工作,我们只配置在 spring 中使用 dubbo 服务
配置依赖,假设 dubbo 使用 zookeeper 作为注册中心
- <dependency>
- <groupId>
- com.alibaba
- </groupId>
- <artifactId>
- dubbo
- </artifactId>
- <version>
- 2.5.3
- </version>
- <exclusions>
- <exclusion>
- <groupId>
- org.springframework
- </groupId>
- <artifactId>
- spring
- </artifactId>
- </exclusion>
- </exclusions>
- </dependency>
- <dependency>
- <groupId>
- com.101tec
- </groupId>
- <artifactId>
- zkclient
- </artifactId>
- <version>
- 0.4
- </version>
- <exclusions>
- <exclusion>
- <artifactId>
- org.apache.zookeeper
- </artifactId>
- <groupId>
- zookeeper
- </groupId>
- </exclusion>
- <exclusion>
- <artifactId>
- zookeeper
- </artifactId>
- <groupId>
- org.apache.zookeeper
- </groupId>
- </exclusion>
- </exclusions>
- </dependency>
- <dependency>
- <groupId>
- org.apache.zookeeper
- </groupId>
- <artifactId>
- zookeeper
- </artifactId>
- <version>
- 3.4.9
- </version>
- </dependency>
在 src/main/resources 的 spring 目录放一个 dubbo-client.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:dubbo="http://code.alibabatech.com/schema/dubbo" xsi:schemaLocation="http://www.springframework.org/schema/beans
- http://www.springframework.org/schema/beans/spring-beans.xsd
- http://code.alibabatech.com/schema/dubbo
- http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
- <!-- 服务名称 -->
- <dubbo:application name="dubbo-demo" />
- <!-- 注册中心 -->
- <dubbo:registry protocol="zookeeper" address="172.17.210.124:2181" />
- <!-- 服务接口 -->
- <dubbo:reference id="demoService" interface="org.dubbo.demo.client.DemoService"
- version="0.0.1" />
- </beans>
然后让 spring 加载 dubbo-client.xml
- <import resource="classpath*:/spring/dubbo-client.xml" />
启动工程,DemoService 接口提供的方法就可以用了,就像调用本地方法一样
- @Controller public class Test {@Autowired private DemoService demoService;@RequestMapping("/test")@ResponseBody public String test() {
- return demoService.test("dubbo-demo-test");
- }
- }
当然,服务使用者需要拿到服务提供者声明服务接口的 jar,在公司内部,这通常也是一个依赖
- <dependency>
- <groupId>
- com.xmyself
- </groupId>
- <artifactId>
- dubbo-demo-client
- </artifactId>
- <version>
- 0.0.1-SNAPSHOT
- </version>
- </dependency>
来源: http://www.cnblogs.com/ywlaker/p/6128718.html