三、 MySQL + Tomcat 工程

Posted on 2014-11-21 20:46 MatchBoxy 阅读(168) 评论(0) 收藏举报

本文内容：

根据上篇文章，搭建简单的 spring mvc web service ，引入数据库操作，通过浏览器 uri 定位 controller 访问修改数据库内容

1、安装 MySQL Server 5.6 。选择 Custom ，只选择 MySQL Server ，指定软件位置和数据存储位置，我的位置如下：

配置信息， mysql56、mysql、mysql ，用户暂时不用添加，端口默认的 3306 即可。安装完成后，开始菜单中找到如下位置

点击上面的命令提示符，提示输入密码，我们没有修改过，所以输入 mysql ，继续输入 show databases; 显示存在的数据库，有 mysql、test 等等，表示安装成功。

开启和关闭 MySQL Server 的方法（共有两种方式）：

（1）需要以管理员身份运行命令提示符， cd 到 F:\Software\MySQL\MySQL Server 5.6\bin 目录下，执行 mysqld.exe -install ，成功后会显示 Service successfully installed. 这样就可以通过 “运行” 或者 “命令提示符” 输入 net start mysql56 和 net stop mysql56 来开启和关闭 MySQL Server 了。

（2）（开始 -> 搜索 “服务” || “运行” services.msc || 控制面板 -> 服务）找到 MySQL56 手动开启或者关闭。

注：要先关闭 mysql 服务 net stop mysql，打开 mysql56 服务 net start mysql56 才行。

2、安装 Navicat for MySQL 11.1.6 。连接 MySQL 连接名 test-connect ，主机名 localhost ，端口3306 ，用户名 root ，密码 mysql 。连接测试，确定。双击连接名即可打开连接，可以添加用户、添加用户权限、添加数据库、修改等等操作。如果双击提示失败，可能是 MySQL Server 没有打开。

注：Navicat 更简单方便一些，而用 MySQL Workbench 更好，功能更多一些。

3、工程配置

（1）配置 pom.xml 文件，引入数据库驱动 .jar 包，将下面的代码添加到 pom.xml 文件中的 <dependencies>___</dependencies> 里面。

 1         <!-- DataBase Driver --> 
 2         <!-- MySQL -->
 3         <dependency>
 4             <groupId>mysql</groupId>
 5             <artifactId>mysql-connector-java</artifactId>
 6             <version>5.1.25</version>
 7         </dependency>
 8         
 9         <dependency>
10             <groupId>com.mchange</groupId>
11             <artifactId>c3p0</artifactId>
12             <version>0.9.5-pre3</version>
13         </dependency>

database driver.xml

（2）建立 database.properties 文件，放在 resources 下面，用来配置数据库信息。项目工程名 -> Java Resources -> src/main/resources -> 右键 -> New -> Class -> 建立 java 文件，命名为 database.java ，然后将其重命名为 database.properties 。里面输入数据库的配置信息，如下：

注： user 和 password 一定要写对，而且后面不能带有空格，否则会连接不上。

 1 driverClass=com.mysql.jdbc.Driver
 2 #jdbcUrl=jdbc:mysql://localhost:3306/my_test_database?useUnicode=true&amp;characterEncoding=UTF-8
 3 jdbcUrl=jdbc:mysql://127.0.0.1:3306/my_test_database?useUnicode=true&amp;characterEncoding=UTF-8
 4 user=root
 5 password=mysql
 6 maxPoolSize=100
 7 minPoolSize=1
 8 initialPoolSize=1
 9 testConnectionOnCheckin=true
10 maxIdleTime=25000
11 acquireIncrement=1
12 acquireRetryAttempts=30
13 acquireRetryDelay=1000
14 automaticTestTable=t_c3p0
15 idleConnectionTestPeriod=18000
16 checkoutTimeout=5000

database.properties

注：要打开 MySQL Server ，并在 Navicat 中建立一个测试数据库，my_test_database，运行如下 sql ，建立一个表，插入四条数据。

 1 drop database if exists my_test_database;
 2 
 3 create database my_test_database;
 4 
 5 use my_test_database;
 6 
 7 create table my_test_table(number int not null, name varchar(40), score int, primary key(number));
 8 
 9 insert into my_test_table(number, name, score) values(1001, "Match", 91);
10 insert into my_test_table(number, name, score) values(1002, "Tom", 92);
11 insert into my_test_table(number, name, score) values(1003, "Slina", 93);
12 insert into my_test_table(number, name, score) values(1004, "Ally", 91);

my_test_database.sql

（3）配置 applicationContext.xml 文件。将下面的代码添加到此文件中，用来配置数据库。

 1     <!-- 配置文件 -->
 2     <bean id="proConfig" class="org.springframework.beans.factory.config.PropertiesFactoryBean">
 3         <property name="locations">
 4             <list>
 5                 <value>classpath*:database.properties</value> 
 6             </list>
 7         </property>
 8     </bean>
 9 
10     <!--MySQL Database-->
11     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
12           destroy-method="close">
13         <property name="driverClass" value="#{proConfig.driverClass}"/>
14         <property name="jdbcUrl" value="#{proConfig.jdbcUrl}"/>
15         <property name="user" value="#{proConfig.user}"/>
16         <property name="password" value="#{proConfig.password}"/>
17         <property name="maxPoolSize" value="#{proConfig.maxPoolSize}"/>
18         <property name="minPoolSize" value="#{proConfig.minPoolSize}"/>
19         <property name="initialPoolSize" value="#{proConfig.initialPoolSize}"/>
20         <property name="testConnectionOnCheckin" value="#{proConfig.testConnectionOnCheckin}"/>
21         <property name="maxIdleTime" value="#{proConfig.maxIdleTime}"/>
22         <property name="acquireIncrement" value="#{proConfig.acquireIncrement}"/>
23         <property name="acquireRetryAttempts" value="#{proConfig.acquireRetryAttempts}"/>
24         <property name="acquireRetryDelay" value="#{proConfig.acquireRetryDelay}"/>
25         <property name="automaticTestTable" value="#{proConfig.automaticTestTable}"/>
26         <property name="idleConnectionTestPeriod" value="#{proConfig.idleConnectionTestPeriod}"/>
27         <property name="checkoutTimeout" value="#{proConfig.checkoutTimeout}"/>
28     </bean>
29     <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
30         <property name="dataSource" ref="dataSource"/>
31     </bean>
32     <bean id="transactionManager"
33           class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
34         <property name="dataSource" ref="dataSource"/>
35     </bean>

database config.xml

4、代码修改

（1）建立 dao 包，用来存放数据库操作类，在 dao 包下面建立一个 interface 类 mydao.java ，代码如下：

1 package dao;
2 
3 import java.util.List;
4 
5 public interface mydao {
6     
7     public List<String> findNameByScore(int score);
8 
9 }

mydao.java

（2）在 dao 包下面建立 impl 包，在 impl 包下面建立一个类 mydaoImpl.java ，它扩展 JdbcDaoSupport ，并实现 mydao ，代码如下：

 1 package dao.impl;
 2 
 3 import java.sql.ResultSet;
 4 import java.sql.SQLException;  
 5 import java.util.List;
 6 
 7 import org.springframework.jdbc.core.RowMapper;
 8 import org.springframework.jdbc.core.support.JdbcDaoSupport;
 9 
10 import dao.mydao;
11 
12 public class mydaoImpl extends JdbcDaoSupport implements mydao {
13     
14     public mydaoImpl()
15     {
16         
17     }
18     
19     @SuppressWarnings({ "unchecked", "rawtypes" })
20     @Override
21     public List<String> findNameByScore(int score)
22     {
23         String sql = "select name from my_test_table where score=" + score;
24         
25         return this.getJdbcTemplate().queryForList(sql, String.class);
26         
27         /*
28         return this.getJdbcTemplate().query(sql, new RowMapper()
29             {
30                 @Override
31                 public Object mapRow(ResultSet rs, int rowNum) throws SQLException
32                 {
33                     return rs.getString("name");
34                 }
35             });
36             */
37             
38     }
39 }

mydaoImpl.java

上面例子只实现了查询，下面给出插入、更新、删除操作的例子，作为参考，不修改进本工程。

 1 package dao.impl;
 2 
 3 import java.sql.Connection;
 4 import java.sql.PreparedStatement;
 5 import java.sql.ResultSet;
 6 import java.sql.SQLException;  
 7 import java.util.List;
 8 
 9 import org.springframework.jdbc.core.PreparedStatementCreator;
10 import org.springframework.jdbc.core.RowMapper;
11 import org.springframework.jdbc.core.support.JdbcDaoSupport;
12 
13 import dao.mydao;
14 
15 public class mydaoImpl extends JdbcDaoSupport implements mydao {
16     
17     public mydaoImpl()
18     {
19         
20     }
21     
22     @SuppressWarnings({ "unchecked", "rawtypes" })
23     @Override
24     public List<String> findNameByScore(int score)
25     {
26         String sql = "select name from my_test_table where score=" + score;
27     
28         //select (1)
29         List<String> list1 = this.getJdbcTemplate().queryForList(sql, String.class);
30         
31         //select (2)
32         /*
33         List<String> list2 =         
34             this.getJdbcTemplate().query(sql, new RowMapper()
35             {
36                 @Override
37                 public Object mapRow(ResultSet rs, int rowNum) throws SQLException
38                 {
39                     return rs.getString("name");
40                 }
41             });
42             */
43         
44         return list1;
45     }
46     
47     @Override
48     public int insertData(int number, String name, int score)
49     {
50         //insert 要先查重，此处未作处理
51         String sql = "insert into my_test_table(number, name, score) values(?, ?, ?)";
52             
53         return this.getJdbcTemplate().update(sql, new Object[] {number, name, score}); 
54         
55         
56         //String sql2 = "insert into ......";
57         //this.getJdbcTemplate().execute(sql2);
58         //return 1;
59         
60         
61         /*
62         return this.getJdbcTemplate().update(new PreparedStatementCreator()
63             {
64                 @Override
65                 public PreparedStatement createPreparedStatement(Connection con) throws SQLException 
66                 {
67                     PreparedStatement ps = con.prepareStatement(sql);
68                     ps.setInt(1, number);
69                     ps.setString(2, name);
70                     ps.setInt(3, score);
71                     return ps;
72                 } 
73             });
74             */
75     }
76     
77     @Override
78     public int updateData(int number, String name, int score)
79     {
80         //update
81         String sql = "update my_test_table set name = \"" + name + "\" , score = " + score + " where number = " + number;
82         
83         return this.getJdbcTemplate().update(sql);
84     }
85     
86     @Override
87     public int deleteData(int number)
88     {
89         //delete
90         String sql = "delete from my_test_table where number = " + number;
91         
92         return this.getJdbcTemplate().update(sql);
93     }
94 }

select-insert-update-delete.java

（3）添加 spring-dao.xml 文件，工程目录 -> Java Resources -> src/main/config -> 右键 -> New -> Other -> 建立 xml 文件，输入如下代码：

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
 5 
 6     <bean id="myDao" class="dao.impl.mydaoImpl">
 7         <property name="dataSource" ref="dataSource" />
 8     </bean>
 9 
10 </beans>

spring-dao.xml

（4）修改 web.xml 文件，只需将新建立的 spring-dao.xml 这个配置文件加入到环境参数中即可，将 classpath*:spring-dao.xml 这行语句添加到 web.xml 文件中的 <context-param> 下面的 <param-value> 里面即可，完成后， web.xml 部分信息如下：

1     <context-param>
2         <param-name>contextConfigLocation</param-name>
3         <param-value>
4             classpath*:applicationContext.xml,
5             classpath*:spring-api.xml,
6             classpath*:spring-dao.xml
7         </param-value>
8     </context-param>

add param.xml

（5）修改 controller.java 文件，添加 mydao 类型的属性，新增 public String getNameList() 方法，用来从数据库读取值，并回显给浏览器用户

1     @Autowired
2     private mydao testDao;

add attribute.java

 1     @RequestMapping(value="/test3", method=RequestMethod.GET)
 2     @ResponseStatus(HttpStatus.OK)
 3     @ResponseBody
 4     public String getNameList()
 5     {
 6         String str = "pre___" + "\n";
 7         
 8         List<String> list = this.testDao.findNameByScore(91);
 9         
10         for(int i=0; i<list.size(); i++)
11         {
12             str += list.get(i);
13             str += "   ";
14         }
15         
16         return str;
17     }

add method.java

5、发布运行。正常情况下，点击运行， maven 会自动管理下载 mysql 的驱动包，一段时间后， Tomcat 服务器成功运行。

打开浏览器，输入 http://localhost:8080/TestServer4/myapi/controller/test3 ，浏览器中会出现 pre___ Match Ally ，表示成功从数据库中读取到 score=91 的所有成员的名字，并将他们连接成一个字符串，中间用空格隔开。其中 pre___ 是预定的内容， Match 和 Ally 是数据库中的内容。至此表示成功从数据库读取到数据。

如上篇所述，用同样方法，是另外一台电脑能访问到本机，比如浏览器输入 http://192.168.1.105:8080/TestServer4/myapi/controller/test3 ，浏览器依然返回 pre___ Match Ally ，表示完全成功。

注：如果浏览器出现异常信息，表示操作失败，需根据异常信息进行判断哪里出现问题。请确保按照上面步骤进行操作，此片实例建立在前两篇（第一篇搭建环境，第二篇编写代码和配置文件，此篇是数据库的搭建及与工程的连接）的基础之上。一些常见的小问题：比如 database.properties 里面的信息， user 或 password 后面跟了多余的空格。

6、完整的工程。将此工程的目录、类、配置信息完整附上。

（1）工程的目录如下：

（2） .java 文件

 1 package com.matchbox;
 2 
 3 import java.io.IOException;
 4 import java.io.PrintWriter;
 5 import java.util.List;
 6 
 7 import javax.servlet.http.HttpServletRequest;
 8 import javax.servlet.http.HttpServletResponse;
 9 
10 import org.springframework.beans.factory.annotation.Autowired;
11 import org.springframework.http.HttpStatus;
12 import org.springframework.stereotype.Controller;
13 import org.springframework.web.bind.annotation.RequestMapping;
14 import org.springframework.web.bind.annotation.RequestMethod;
15 import org.springframework.web.bind.annotation.ResponseBody;
16 import org.springframework.web.bind.annotation.ResponseStatus;
17 
18 import dao.mydao;
19 
20 @Controller
21 @RequestMapping("/controller")
22 public class controller {
23     
24     @Autowired
25     private mydao testDao;
26     
27     @RequestMapping(value="/test1", method=RequestMethod.GET)
28     @ResponseStatus(HttpStatus.OK)
29     @ResponseBody
30     public String doShow()
31     {
32         System.out.println("abc");
33         return "ABC";
34     }
35     
36     @RequestMapping(value="/test2", method=RequestMethod.GET)
37     public void hello(HttpServletRequest request, HttpServletResponse response) throws IOException 
38     {                 
39         response.setContentType("text/html;charset=GB2312");
40         
41         PrintWriter out = response.getWriter();
42         
43         out.println("<html><head><title>Result</title></head> <body><b> LT's Home Server From Controller </b></body></html>");
44         out.close();
45     }   
46     
47     @RequestMapping(value="/test3", method=RequestMethod.GET)
48     @ResponseStatus(HttpStatus.OK)
49     @ResponseBody
50     public String getNameList()
51     {
52         String str = "pre___" + "\n";
53         
54         List<String> list = this.testDao.findNameByScore(91);
55         
56         for(int i=0; i<list.size(); i++)
57         {
58             str += list.get(i);
59             str += "   ";
60         }
61         
62         return str;
63     }
64 }

controller.java

1 package dao;
2 
3 import java.util.List;
4 
5 public interface mydao {
6     
7     public List<String> findNameByScore(int score);
8 
9 }

mydao.java

 1 package dao.impl;
 2 
 3 import java.sql.ResultSet;
 4 import java.sql.SQLException;  
 5 import java.util.List;
 6 
 7 import org.springframework.jdbc.core.RowMapper;
 8 import org.springframework.jdbc.core.support.JdbcDaoSupport;
 9 
10 import dao.mydao;
11 
12 public class mydaoImpl extends JdbcDaoSupport implements mydao {
13     
14     public mydaoImpl()
15     {
16         
17     }
18     
19     @SuppressWarnings({ "unchecked", "rawtypes" })
20     @Override
21     public List<String> findNameByScore(int score)
22     {
23         String sql = "select name from my_test_table where score=" + score;
24         
25         return this.getJdbcTemplate().queryForList(sql, String.class);
26         
27         /*
28         return this.getJdbcTemplate().query(sql, new RowMapper()
29             {
30                 @Override
31                 public Object mapRow(ResultSet rs, int rowNum) throws SQLException
32                 {
33                     return rs.getString("name");
34                 }
35             });
36             */
37             
38     }
39 }

mydaoImpl.java

（3） .xml 文件

 1 <web-app xmlns="http://java.sun.com/xml/ns/javaee" 
 2     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 3     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
 4     http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
 5     version="2.5">
 6     
 7       <display-name>Archetype Created Web Application</display-name>
 8   
 9       <listener>
10         <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
11     </listener>
12     
13     
14     <context-param>
15         <param-name>contextConfigLocation</param-name>
16         <param-value>
17             classpath*:applicationContext.xml,
18             classpath*:spring-api.xml,
19             classpath*:spring-dao.xml
20         </param-value>
21     </context-param>
22     
23    
24     <servlet>
25         <servlet-name>dispatcher</servlet-name>
26         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
27         <init-param>
28             <param-name>contextConfigLocation</param-name>
29             <param-value>classpath*:spring-api.xml</param-value>
30         </init-param>
31         <load-on-startup>1</load-on-startup>
32     </servlet>
33  
34     <servlet-mapping>
35         <servlet-name>dispatcher</servlet-name>
36         <url-pattern>/myapi/*</url-pattern>
37     </servlet-mapping>
38  
39     
40     <listener>
41         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
42     </listener>
43  
44  
45      <welcome-file-list>
46         <welcome-file>index.jsp</welcome-file>
47     </welcome-file-list>
48     
49 </web-app>

web.xml

  1 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  3     <modelVersion>4.0.0</modelVersion>
  4     <groupId>com.matchbox.test</groupId>
  5     <artifactId>TestServer4</artifactId>
  6     <packaging>war</packaging>
  7     <version>0.0.1-SNAPSHOT</version>
  8     <name>TestServer4 Maven Webapp</name>
  9     <url>http://maven.apache.org</url>
 10 
 11     <properties>
 12         <org.springframework.version>3.2.5.RELEASE</org.springframework.version>
 13     </properties>
 14   
 15     <dependencies>
 16         <!-- spring -->    
 17         <dependency>
 18             <groupId>org.springframework</groupId>
 19             <artifactId>spring-core</artifactId>
 20             <version>${org.springframework.version}</version>
 21         </dependency>
 22         <dependency>
 23             <groupId>org.springframework</groupId>
 24             <artifactId>spring-beans</artifactId>
 25             <version>${org.springframework.version}</version>
 26         </dependency>
 27         <dependency>
 28             <groupId>org.springframework</groupId>
 29             <artifactId>spring-expression</artifactId>
 30             <version>${org.springframework.version}</version>
 31         </dependency>
 32         <dependency>
 33             <groupId>org.springframework</groupId>
 34             <artifactId>spring-context-support</artifactId>
 35             <version>${org.springframework.version}</version>
 36         </dependency>
 37         <dependency>
 38             <groupId>org.springframework</groupId>
 39             <artifactId>spring-context</artifactId>
 40             <version>${org.springframework.version}</version>
 41         </dependency>
 42         
 43         <dependency>
 44             <groupId>org.springframework</groupId>
 45             <artifactId>spring-jdbc</artifactId>
 46             <version>${org.springframework.version}</version>
 47         </dependency>
 48         <dependency>
 49             <groupId>org.springframework</groupId>
 50             <artifactId>spring-orm</artifactId>
 51             <version>${org.springframework.version}</version>
 52         </dependency>
 53         <dependency>
 54             <groupId>org.springframework</groupId>
 55             <artifactId>spring-oxm</artifactId>
 56             <version>${org.springframework.version}</version>
 57         </dependency>
 58         <dependency>
 59             <groupId>org.springframework</groupId>
 60             <artifactId>spring-web</artifactId>
 61             <version>${org.springframework.version}</version>
 62         </dependency>
 63         <dependency>
 64             <groupId>org.springframework</groupId>
 65             <artifactId>spring-webmvc</artifactId>
 66             <version>${org.springframework.version}</version>
 67         </dependency>
 68         <dependency>
 69             <groupId>org.springframework</groupId>
 70             <artifactId>spring-aop</artifactId>
 71             <version>${org.springframework.version}</version>
 72         </dependency>
 73         <dependency>
 74             <groupId>org.aspectj</groupId>
 75             <artifactId>aspectjweaver</artifactId>
 76             <version>1.7.4</version>
 77         </dependency>
 78         <dependency>
 79             <groupId>org.springframework</groupId>
 80             <artifactId>spring-tx</artifactId>
 81             <version>${org.springframework.version}</version>
 82         </dependency>
 83         <dependency>
 84             <groupId>org.springframework.security.oauth</groupId>
 85             <artifactId>spring-security-oauth2</artifactId>
 86             <version>1.0.5.RELEASE</version>
 87         </dependency>
 88         <dependency>
 89             <groupId>org.springframework</groupId>
 90             <artifactId>spring-test</artifactId>
 91             <version>${org.springframework.version}</version>
 92             <scope>test</scope>
 93         </dependency>
 94         
 95         <!-- servlet-->
 96         <dependency>
 97             <groupId>javax.servlet</groupId>
 98             <artifactId>servlet-api</artifactId>
 99             <version>3.0-alpha-1</version>
100         </dependency>
101        
102         <!-- MessageConverter-->
103         <dependency>
104             <groupId>com.fasterxml.jackson.core</groupId>
105             <artifactId>jackson-core</artifactId>
106             <version>2.3.0</version>
107         </dependency>
108         <dependency>
109             <groupId>com.fasterxml.jackson.core</groupId>
110             <artifactId>jackson-databind</artifactId>
111             <version>2.3.0</version>
112         </dependency>
113         
114         <!-- log4J -->
115         <dependency>
116             <groupId>commons-logging</groupId>
117             <artifactId>commons-logging</artifactId>
118             <version>1.1.3</version>
119         </dependency>
120         <dependency>
121             <groupId>log4j</groupId>
122             <artifactId>log4j</artifactId>
123             <version>1.2.17</version>
124         </dependency>
125         <dependency>
126             <groupId>org.apache.httpcomponents</groupId>
127             <artifactId>httpclient</artifactId>
128             <version>4.3.1</version>
129         </dependency>
130         
131         <!-- DataBase Driver --> 
132         <!-- MySQL -->
133         <dependency>
134             <groupId>mysql</groupId>
135             <artifactId>mysql-connector-java</artifactId>
136             <version>5.1.25</version>
137         </dependency>
138         
139         <dependency>
140             <groupId>com.mchange</groupId>
141             <artifactId>c3p0</artifactId>
142             <version>0.9.5-pre3</version>
143         </dependency>
144         
145         <dependency>
146             <groupId>commons-beanutils</groupId>
147             <artifactId>commons-beanutils</artifactId>
148             <version>1.9.0</version>
149         </dependency>
150         <dependency>
151             <groupId>commons-lang</groupId>
152             <artifactId>commons-lang</artifactId>
153             <version>2.6</version>
154         </dependency>
155         <dependency>
156             <groupId>commons-pool</groupId>
157             <artifactId>commons-pool</artifactId>
158             <version>20030825.183949</version>
159         </dependency>
160         <!-- 数据库持久化notation-->
161         <dependency>
162             <groupId>org.eclipse.persistence</groupId>
163             <artifactId>javax.persistence</artifactId>
164             <version>2.1.0</version>
165         </dependency>
166         
167     </dependencies>
168   
169 
170     <build>
171         <finalName>TestServer4</finalName>
172     </build>
173 </project>

pom.xml

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
 5 
 6     <!-- 配置文件 -->
 7     <bean id="proConfig" class="org.springframework.beans.factory.config.PropertiesFactoryBean">
 8         <property name="locations">
 9             <list>
10                 <value>classpath*:database.properties</value> 
11             </list>
12         </property>
13     </bean>
14 
15     <!--MySQL Database-->
16     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
17           destroy-method="close">
18         <property name="driverClass" value="#{proConfig.driverClass}"/>
19         <property name="jdbcUrl" value="#{proConfig.jdbcUrl}"/>
20         <property name="user" value="#{proConfig.user}"/>
21         <property name="password" value="#{proConfig.password}"/>
22         <property name="maxPoolSize" value="#{proConfig.maxPoolSize}"/>
23         <property name="minPoolSize" value="#{proConfig.minPoolSize}"/>
24         <property name="initialPoolSize" value="#{proConfig.initialPoolSize}"/>
25         <property name="testConnectionOnCheckin" value="#{proConfig.testConnectionOnCheckin}"/>
26         <property name="maxIdleTime" value="#{proConfig.maxIdleTime}"/>
27         <property name="acquireIncrement" value="#{proConfig.acquireIncrement}"/>
28         <property name="acquireRetryAttempts" value="#{proConfig.acquireRetryAttempts}"/>
29         <property name="acquireRetryDelay" value="#{proConfig.acquireRetryDelay}"/>
30         <property name="automaticTestTable" value="#{proConfig.automaticTestTable}"/>
31         <property name="idleConnectionTestPeriod" value="#{proConfig.idleConnectionTestPeriod}"/>
32         <property name="checkoutTimeout" value="#{proConfig.checkoutTimeout}"/>
33     </bean>
34     <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
35         <property name="dataSource" ref="dataSource"/>
36     </bean>
37     <bean id="transactionManager"
38           class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
39         <property name="dataSource" ref="dataSource"/>
40     </bean>
41 
42 </beans>

applicationContext.xml

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
 5 
 6     <bean id="myDao" class="dao.impl.mydaoImpl">
 7         <property name="dataSource" ref="dataSource" />
 8     </bean>
 9 
10 </beans>

spring-dao.xml

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4        xmlns:context="http://www.springframework.org/schema/context"
 5        xmlns:mvc="http://www.springframework.org/schema/mvc"
 6        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 http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd">
 7 
 8     <context:component-scan base-package="com.matchbox" />
 9     
10     <!-- http.get 的时候，如果uri中带中文参数，需要设置get方法的header的Content-Type为utf-8 -->
11     <mvc:annotation-driven>
12         <mvc:message-converters> 
13             <!-- StringHttpMessageConverter 默认采用的是 text/plain;charset=ISO-8859-1 -->
14                <!-- RESTClient 响应 Content-Type: text/plain;charset=UTF-8 -->
15             <bean class="org.springframework.http.converter.StringHttpMessageConverter">
16                 <property name="supportedMediaTypes">
17                     <list>
18                         <value>text/plain;charset=UTF-8</value>
19                     </list>
20                 </property>
21             </bean>
22             
23             <!-- json格式的自动转换-->
24             <!-- RESTClient 响应 Content-Type: application/json;charset=UTF-8 -->
25             <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
26         </mvc:message-converters> 
27     </mvc:annotation-driven>  
28     
29 </beans>

spring-api.xml

（4） .properties 文件

 1 driverClass=com.mysql.jdbc.Driver
 2 #jdbcUrl=jdbc:mysql://localhost:3306/my_test_database?useUnicode=true&amp;characterEncoding=UTF-8
 3 jdbcUrl=jdbc:mysql://127.0.0.1:3306/my_test_database?useUnicode=true&amp;characterEncoding=UTF-8
 4 user=root
 5 password=mysql
 6 maxPoolSize=100
 7 minPoolSize=1
 8 initialPoolSize=1
 9 testConnectionOnCheckin=true
10 maxIdleTime=25000
11 acquireIncrement=1
12 acquireRetryAttempts=30
13 acquireRetryDelay=1000
14 automaticTestTable=t_c3p0
15 idleConnectionTestPeriod=18000
16 checkoutTimeout=5000

database.properties

刷新页面返回顶部

match123

导航

公告

三、 MySQL + Tomcat 工程