【Maven由浅入深】4.在Eclipse中建立简单的项目1
我们上次讲到如何在Eclipse中创建Maven项目了，我们接下来来看看Maven用到了什么。
我们下面用maven开发一个简单的用户信息管理系统，我们就直接使用上一次创建的user-core来做这个系统。
我们在cn.edu.hpu.user.model包下创建一个user类
其中内容
我们要存储对象至数据库，就需要使用hibernate，那么我们就需要在POM配置文件中去引入它，因为我们不知道该怎么去写相应的配置参数，所以我们要登录mvnrepository.com，利用中央仓库的搜索引擎去找到我们需要的jar包，点击相应jar包可以找到配置参数：
然后我们的项目的环境中就有了这个jar包
其实是maven从网络中心仓库下载至我们本地仓库中的：
hibernate引入后，然后修改我们的user，给它加上注解：
然后我们在pom中加上mysql的数据库连接驱动：
然后是log4j的：
然后接下来写hibernate的配置文件:
以及log4j配置文件：
现在我们完成了所有配置，接下来写HibernateUtil来获取SessionFactory：
接下来我们来编写Dao层：
IUserDao:
UserDao:
由于我们接下来要隔离数据库进行操作，所以需要dbunit工具类，我们在pom中导入它:
测试不要和hibernate的Connection混用，我们使用原始的JDBC的链接：
DbUtil:
接下来编写AbstractDbUnitTestCase和EntitiesHelper两个测试用类
AbstractDbUnitTestCase:
EntitiesHelper:
然后我们写一下user的文件t_user.xml，将其放入src/test/resource中
然后开始写测试类：
然后我们鼠标右键点击项目，然后选择Run As...，然后选择Maven Build:
我们输入两个指令(clean test)，现清空，然后再测试:
结果在控制台中显示，target文件夹中的测试报告中也有(如果出错了，点击txt有结果，点击下面Junit的txt文件会跳转至Junit测试台):
我们下面用maven开发一个简单的用户信息管理系统，我们就直接使用上一次创建的user-core来做这个系统。
我们在cn.edu.hpu.user.model包下创建一个user类
其中内容
package cn.edu.hpu.user.model;
public class User
{
private int id;
private String username;
private String password;
private String nickname;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getNickname() {
return nickname;
}
public void setNickname(String nickname) {
this.nickname = nickname;
}
}
我们要存储对象至数据库，就需要使用hibernate，那么我们就需要在POM配置文件中去引入它，因为我们不知道该怎么去写相应的配置参数，所以我们要登录mvnrepository.com，利用中央仓库的搜索引擎去找到我们需要的jar包，点击相应jar包可以找到配置参数：
<dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-entitymanager</artifactId> <version>4.1.10.Final</version> </dependency>
然后我们的项目的环境中就有了这个jar包
其实是maven从网络中心仓库下载至我们本地仓库中的：
hibernate引入后，然后修改我们的user，给它加上注解：
package cn.edu.hpu.user.model;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name="t_user")
public class User
{
private int id;
private String username;
private String password;
private String nickname;
public User() {
super();
}
public User(String username, String password, String nickname) {
super();
this.username = username;
this.password = password;
this.nickname = nickname;
}
public User(int id, String username, String password, String nickname){
super();
this.id = id;
this.username = username;
this.password = password;
this.nickname = nickname;
}
@Id
@GeneratedValue
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getNickname() {
return nickname;
}
public void setNickname(String nickname) {
this.nickname = nickname;
}
}
然后我们在pom中加上mysql的数据库连接驱动：
<dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.24</version> </dependency>
然后是log4j的：
<dependency> <groupId>log4j</groupId> <artifactId>log4j</artifactId> <version>1.2.17</version> </dependency>
然后接下来写hibernate的配置文件:
<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd"> <hibernate-configuration> <session-factory> <property name="hibernate.connection.username">root</property> <property name="hibernate.connection.password">1234</property> <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property> <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/maven_user</property> <!-- 控制事务自动提交 --> <property name="hibernate.connection.autocommit">true</property> <!-- 配置方言 --> <property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property> <!-- 数据库定义语言(none，update，create) --> <!-- 选update的原因是如果没有表，给我创建，有表直接追加数据，字段发生变化就更新表的结构 --> <!-- create只能创建表，每次都是新表。none如果没有表不能创建，会抛出异常 --> <property name="hibernate.hbm2ddl.auto">update</property> <property name="hibernate.show_sql">true</property> <property name="format_sql">true</property> <!-- 加入实体类的映射文件 --> <mapping class="cn.edu.hpu.user.model.User"/> </session-factory> </hibernate-configuration>
以及log4j配置文件：
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p [%t] %c{1}:%L - %m%n
log4j.rootLogger=warn, stdout, R
log4j.logger.cn.edu.hpu=debug
log4j.appender.R=org.apache.log4j.DailyRollingFileAppender
log4j.appender.R.File=F:/tax/UserSys.log
log4j.appender.R.layout=org.apache.log4j.PatternLayout
log4j.appender.R.layout.ConversionPattern=%d [%t] %5p %c - %m%n
现在我们完成了所有配置，接下来写HibernateUtil来获取SessionFactory：
package cn.edu.hpu.user.util;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
public class HibernateUtil {
private final static SessionFactory FACTORY = buildSessionFactory();
private static SessionFactory buildSessionFactory() {
Configuration cfg=new Configuration().configure();
ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().applySettings(cfg.getProperties()).buildServiceRegistry();
SessionFactory factory=cfg.buildSessionFactory(serviceRegistry);
return factory;
}
public static SessionFactory getFactory() {
return FACTORY;
}
public static Session openSession(){
return FACTORY.openSession();
}
public static void close(Session session){
if(session!=null) session.close();
}
}
接下来我们来编写Dao层：
IUserDao:
package cn.edu.hpu.user.dao;
import cn.edu.hpu.user.model.User;
public interface IUserDao {
public void add(User user);
public User loadUsername(String username);
}
UserDao:
package cn.edu.hpu.user.dao;
import org.hibernate.Session;
import cn.edu.hpu.user.model.User;
import cn.edu.hpu.user.util.HibernateUtil;
public class UserDao implements IUserDao {
public void add(User user) {
Session session = null;
try {
session=HibernateUtil.openSession();
session.beginTransaction();
session.save(user);
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
}finally{
HibernateUtil.close(session);
}
}
public User loadUsername(String username) {
Session session = null;
User user=null;
try {
session=HibernateUtil.openSession();
user=(User) session.createQuery("from User where username=?")
.setParameter(0, username).uniqueResult();
} catch (Exception e) {
e.printStackTrace();
}finally{
HibernateUtil.close(session);
}
return user;
}
}
由于我们接下来要隔离数据库进行操作，所以需要dbunit工具类，我们在pom中导入它:
<dependency> <groupId>dbunit</groupId> <artifactId>dbunit</artifactId> <version>2.2</version> </dependency>
测试不要和hibernate的Connection混用，我们使用原始的JDBC的链接：
DbUtil:
package cn.edu.hpu.user.util;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class DbUtil {
// 定义MySQL的数据库驱动程序
public static final String DBDRIVER = "org.gjt.mm.mysql.Driver" ;
//定义mysql的数据库连接地址：
public static final String DBDURL = "jdbc:mysql://localhost:3306/maven_user" ;
//mysql数据库的连接用户名
public static final String DBUSER = "root" ;
//mysql数据库的连接密码
public static final String DBPASS = "1234" ;
static{
try {
Class.forName(DBDRIVER);
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static Connection getConnection(){
Connection conn=null;
try {
conn=DriverManager.getConnection(DBDURL,DBUSER,DBPASS);
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return conn;
}
public static void close(ResultSet rs,Statement st,Connection conn){
try {
if(rs!=null){
rs.close();
}
if(st!=null){
st.close();
}
if(conn!=null){
conn.close();
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void close(Statement st,Connection conn){
close(null,st,conn);
}
}
接下来编写AbstractDbUnitTestCase和EntitiesHelper两个测试用类
AbstractDbUnitTestCase:
package cn.edu.hpu.user.util;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.sql.SQLException;
import org.dbunit.DatabaseUnitException;
import org.dbunit.database.DatabaseConnection;
import org.dbunit.database.IDatabaseConnection;
import org.dbunit.database.QueryDataSet;
import org.dbunit.dataset.DataSetException;
import org.dbunit.dataset.IDataSet;
import org.dbunit.dataset.xml.FlatXmlDataSet;
import org.dbunit.operation.DatabaseOperation;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.BeforeClass;
public class AbstractDbUnitTestCase {
public static IDatabaseConnection dbunitCon;
private File tempFile;
@BeforeClass
public static void init() throws Exception{
dbunitCon = new DatabaseConnection(DbUtil.getConnection());
}
protected IDataSet createDataSet(String tname)throws DataSetException,IOException{
InputStream is=AbstractDbUnitTestCase
.class
.getClassLoader().getResourceAsStream("dbunit_xml/"+tname+"xml");
Assert.assertNotNull("dbunit的基本数据文件不存在！", is);
return new FlatXmlDataSet(is);
}
protected void backupAllTable() throws SQLException,IOException,DataSetException{
IDataSet ds=dbunitCon.createDataSet();
writeBackupFile(ds);
}
private void writeBackupFile(IDataSet ds) throws IOException, DataSetException {
tempFile=File.createTempFile("back","xml");
FlatXmlDataSet.write(ds, new FileWriter(tempFile));
}
protected void backupCustomTable(String [] tname)throws DataSetException, SQLException, IOException{
QueryDataSet ds=new QueryDataSet(dbunitCon);
for(String str:tname){
ds.addTable(str);
}
writeBackupFile(ds);
}
protected void backupOneTable(String tname)throws DataSetException, SQLException, IOException{
backupCustomTable(new String[]{tname});
}
protected void resumeTable() throws IOException, DatabaseUnitException, SQLException{
IDataSet ds=new FlatXmlDataSet(tempFile);
DatabaseOperation.CLEAN_INSERT.execute(dbunitCon,ds);
}
@AfterClass
public static void destory(){
try {
if(dbunitCon!=null) dbunitCon.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
EntitiesHelper:
package cn.edu.hpu.user.util;
import org.junit.Assert;
import cn.edu.hpu.user.model.User;
public class EntitiesHelper {
private static User baseUser=new User(1,"admin","123","管理员");
public static void assertUser(User expected,User actual){
Assert.assertNotNull(expected);
Assert.assertEquals(expected.getId(), actual.getId());
Assert.assertEquals(expected.getUsername(), actual.getUsername());
Assert.assertEquals(expected.getPassword(), actual.getPassword());
Assert.assertEquals(expected.getNickname(), actual.getNickname());
}
public static void assertUser(User expected){
assertUser(expected,baseUser);
}
}
然后我们写一下user的文件t_user.xml，将其放入src/test/resource中
<?xml version="1.0" encoding="UTF-8"?> <dataset> <t_user id="1" username="admin" password="123" nickname="管理员"/> </dataset>
然后开始写测试类：
package cn.edu.hpu.user.dao;
import java.io.IOException;
import java.sql.SQLException;
import org.dbunit.DatabaseUnitException;
import org.dbunit.dataset.DataSetException;
import org.dbunit.dataset.IDataSet;
import org.dbunit.operation.DatabaseOperation;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import cn.edu.hpu.user.model.User;
import cn.edu.hpu.user.util.AbstractDbUnitTestCase;
import cn.edu.hpu.user.util.EntitiesHelper;
public class TestUserDao extends AbstractDbUnitTestCase{
private IUserDao userDao;
@Before
public void setUp() throws DataSetException, SQLException, IOException{
userDao =new UserDao();
backupOneTable("t_user");
}
@Test
public void testLoad() throws IOException, DatabaseUnitException, SQLException{
IDataSet ds=createDataSet("t_user");
DatabaseOperation.TRUNCATE_TABLE.execute(dbunitCon, ds);
User tu=userDao.loadUsername("admin");
EntitiesHelper.assertUser(tu);
}
@Test
public void testAdd() throws IOException, DatabaseUnitException, SQLException{
IDataSet ds=createDataSet("t_user");
DatabaseOperation.TRUNCATE_TABLE.execute(dbunitCon, ds);
User user=new User("admin","123","管理员");
userDao.add(user);
Assert.assertTrue(user.getId()>0);
User tu=userDao.loadUsername("admin");
EntitiesHelper.assertUser(tu,user);
}
@After
public void tearDown() throws IOException, DatabaseUnitException, SQLException{
resumeTable();
}
}
然后我们鼠标右键点击项目，然后选择Run As...，然后选择Maven Build:
我们输入两个指令(clean test)，现清空，然后再测试:
结果在控制台中显示，target文件夹中的测试报告中也有(如果出错了，点击txt有结果，点击下面Junit的txt文件会跳转至Junit测试台):
我们算是完成了项目中一部分模块了，下一次我们将写下一个模块，日志模块。
转载请注明出处：http://blog.csdn.net/acmman/article/details/50620095