zoukankan      html  css  js  c++  java

  • 【Spring实战-3】Spring整合Hibernate、Struts

    作者：ssslinppp     

    1. 摘要

    版本：
    Spring4.0.4；Hibernate4.3.5；struts2.3.16；
    主要介绍了如下内容：
    1. 项目结构的规划；
    2. Spring下整合Hibernate的具体过程；
    3. 整合struts的过程；
    4. 重点介绍Dao层的设计；

    2. 项目结构


    lib文件：



    3. web.xml

    因为需要整合struts和Hibernate，所以需要配置spring监听器、以及struts分发器。

    1. <?xml version="1.0" encoding="GBK"?>
    2. <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
    3. 	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4. 	xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
    5. 	http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" version="3.1">
    6. 	<listener>
    7. 		<listener-class>org.springframework.web.context.ContextLoaderListener
    8. 		</listener-class>
    9. 	</listener>
    11. 	<filter>
    12. 		<filter-name>struts2</filter-name>
    13. 		<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
    14. 	</filter>
    15. 	<filter-mapping>
    16. 		<filter-name>struts2</filter-name>
    17. 		<url-pattern>/*</url-pattern>
    18. 	</filter-mapping>
    20. 	<welcome-file-list>
    21. 		<welcome-file>/WEB-INF/content/bookForm.jsp</welcome-file>
    22. 	</welcome-file-list>
    23. </web-app>


    4. applicationContext.xml

    主要完成了如下工作：
    1. 首先需要配置 数据源，这里使用C3P0数据源；
    2. 配置sessionFactory；
    3. 配置Hibernate事务管理器；
    4. 配置切入点、通告等；



    1. <?xml version="1.0" encoding="GBK"?>
    2. <beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    3. 	xmlns="http://www.springframework.org/schema/beans"
    4. 	xmlns:p="http://www.springframework.org/schema/p"
    5. 	xmlns:tx="http://www.springframework.org/schema/tx"
    6. 	xmlns:aop="http://www.springframework.org/schema/aop"
    7. 	xsi:schemaLocation="http://www.springframework.org/schema/beans
    8. 	http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
    9. 	http://www.springframework.org/schema/tx
    10. 	http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
    11. 	http://www.springframework.org/schema/aop
    12. 	http://www.springframework.org/schema/aop/spring-aop-4.0.xsd">
    13. 	
    14. 	<!-- 定义数据源Bean，使用C3P0数据源实现，并注入数据源的必要信息 -->
    15. 	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
    16. 		destroy-method="close"
    17. 		p:driverClass="com.mysql.jdbc.Driver"
    18. 		p:jdbcUrl="jdbc:mysql://localhost:3306/sampledb"
    19. 		p:user="root"
    20. 		p:password="qaz"
    21. 		p:maxPoolSize="40"
    22. 		p:minPoolSize="2"
    23. 		p:initialPoolSize="2"
    24. 		p:maxIdleTime="30"/>
    25. 	
    26. 	<!-- 定义Hibernate的SessionFactory，SessionFactory需要依赖数据源，注入dataSource -->
    27. 	<bean id="sessionFactory" 
    28. 		class="org.springframework.orm.hibernate4.LocalSessionFactoryBean"
    29. 		p:dataSource-ref="dataSource">
    30. 		
    31. 		<!-- annotatedClasses用来列出全部持久化类 -->
    32. 		<property name="annotatedClasses">
    33. 			<list>
    34. 				<!-- 以下用来列出所有的PO类-->
    35. 				<value>org.crazyit.booksys.domain.Book</value>
    36. 			</list>
    37. 		</property>
    38. 		
    39. 		<!-- 定义Hibernate SessionFactory的属性 -->
    40. 		<property name="hibernateProperties">
    41. 			<props>
    42. 				<!-- 指定Hibernate的连接方言 -->
    43. 				<prop key="hibernate.dialect">
    44. 					org.hibernate.dialect.MySQL5InnoDBDialect</prop>
    45. 				<!--是否根据Hiberante映射创建数据表 -->
    46. 				<prop key="hibernate.hbm2ddl.auto">update</prop>
    47. 				<prop key="hibernate.show_sql">true</prop>
    48. 				<prop key="hibernate.format_sql">true</prop>				
    49. 			</props>
    50. 		</property>
    51. 	</bean>
    53. 	<!-- 定义Service组件，并将DAO组件注入Service组件 -->	
    54. 	<bean id="bookService" class="org.crazyit.booksys.service.impl.BookServiceImpl"
    55. 		p:bookDao-ref="bookDao"/>
    56. 	
    57. 	<!-- 定义DAO组件，并将SessionFactory注入DAO组件 -->		
    58. 	<bean id="bookDao" class="org.crazyit.booksys.dao.impl.BookDaoHibernate4"
    59. 		p:sessionFactory-ref="sessionFactory"/>
    60. 	
    61. 	<!-- 配置Hibernate的局部事务管理器，使用HibernateTransactionManager类 -->
    62. 	<!-- 该类是PlatformTransactionManager接口针对采用Hibernate的特定实现类 -->
    63. 	<!-- 配置HibernateTransactionManager需依赖注入SessionFactory -->
    64. 	<bean id="transactionManager" 
    65. 		class="org.springframework.orm.hibernate4.HibernateTransactionManager"
    66. 		p:sessionFactory-ref="sessionFactory"/>
    68. 	<!-- 配置事务增强处理Bean,指定事务管理器 -->
    69. 	<tx:advice id="txAdvice" 
    70. 		transaction-manager="transactionManager">
    71. 		<!-- 用于配置详细的事务定义 -->
    72. 		<tx:attributes>
    73. 			<!-- 所有以'get'开头的方法是read-only的 -->
    74. 			<tx:method name="get*" read-only="true"/>
    75. 			<!-- 其他方法使用默认的事务设置，指定超时时长为5秒 -->
    76. 			<tx:method name="*" isolation="DEFAULT"
    77. 				propagation="REQUIRED" timeout="5"/>
    78. 		</tx:attributes>
    79. 	</tx:advice>
    80. 	
    81. 	<!-- AOP配置的元素 -->
    82. 	<aop:config>
    83. 		<!-- 配置一个切入点 -->
    84. 		<aop:pointcut id="myPointcut" expression="bean(bookService)"/>
    85. 		<!-- 指定在myPointcut切入点应用txAdvice事务增强处理 -->
    86. 		<aop:advisor advice-ref="txAdvice" 
    87. 			pointcut-ref="myPointcut"/>
    88. 	</aop:config>
    89. 	
    90. </beans>

    5. struts.xml
    struts.xml配置文件，没有多少要说明的，就是常规的。

    1. <?xml version="1.0" encoding="GBK"?>
    2. <!-- 指定Struts 2配置文件的DTD信息 -->
    3. <!DOCTYPE struts PUBLIC
    4. 	"-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
    5. 	"http://struts.apache.org/dtds/struts-2.3.dtd">
    6. <struts>
    7. 	<!-- 配置了系列常量 -->
    8. 	<constant name="struts.i18n.encoding" value="GBK"/>
    9. 	<constant name="struts.enable.DynamicMethodInvocation" value="false" />
    10. 	<constant name="struts.devMode" value="true"/>	
    11. 	<package name="lee" extends="struts-default">
    12. 		
    13. 		<action name="addBook" class="org.crazyit.booksys.action.BookAction"
    14. 			method="add">
    15. 			<!-- 添加图书成功，列出所有图书 -->
    16. 			<result type="chain">listBooks</result>
    17. 			<!-- 添加图书失败，跳转到添加图书的表单页 -->
    18. 			<result name="error">/WEB-INF/content/bookForm.jsp</result>
    19. 		</action>
    20. 		
    21. 		<action name="listBooks" class="org.crazyit.booksys.action.BookAction"
    22. 			method="list">
    23. 			<result>/WEB-INF/content/listBooks.jsp</result>
    24. 		</action>
    25. 		
    26. 		<action name="deleteBook" class="org.crazyit.booksys.action.BookAction"
    27. 			method="delete">
    28. 			<result type="chain">listBooks</result>
    29. 		</action>		
    31. 		<!-- 让用户直接访问该应用时列出所有视图页面 -->
    32. 		<action name="*">
    33. 			<result>/WEB-INF/content/{1}.jsp</result>
    34. 		</action>
    35. 	</package>
    36. </struts>

    6. Dao层设计

    项目时分层设计结构，分为控制层、业务层、持久层（Dao）层、PO层（持久化对象），如下图：


    在进行Dao层设计的时候，我们按照接口编程的原则，如下图所示：
    dao层作为持久层，需要与数据库打交道，而所有的数据库操作基本都涉及增、删、改、查等相同的基本操作，而这些通用的操作主要包括：
    1. 根据ID加载实体；
    2. 保存实体；
    3. 更新实体；
    4. 删除实体；
    5. 根据ID删除实体；
    6. 获取所有实体；
    7. 获取实体总数；
    8. 等等等；
    我们可以编写一个dao层基类来实现这些基本操作，然后让其他的dao层类来继承这个基类，这样就可以减少重复的工作量。
    dao层基类的编写也采用按照接口编程的原则，这样我们就可以得到继承关系图，如下所示：


    dao层基类接口：BaseDao.java
    1. package org.crazyit.common.dao;
    3. import java.util.List;
    4. import java.io.Serializable;
    6. public interface BaseDao<T>
    7. {
    8. 	// 根据ID加载实体
    9. 	T get(Class<T> entityClazz , Serializable id);
    10. 	// 保存实体
    11. 	Serializable save(T entity);
    12. 	// 更新实体
    13. 	void update(T entity);
    14. 	// 删除实体
    15. 	void delete(T entity);
    16. 	// 根据ID删除实体
    17. 	void delete(Class<T> entityClazz , Serializable id);
    18. 	// 获取所有实体
    19. 	List<T> findAll(Class<T> entityClazz);
    20. 	// 获取实体总数
    21. 	long findCount(Class<T> entityClazz);
    22. }
    dao层基类实现类：BaseDaoHibernate4.java
    说明：程序中有两个实现类，分别对应Hibernate3和Hibernate4的，我们推荐使用Hibernate4的实现类。
    Hibernate配置时，需要配置sessionFactory，这个sessionFactory实际上就是对应数据库，我们可以通过sessionFactory获取对应的session（相当于数据库连接），然后通过session对数据库进行访问，因此，如果我们想对数据库进行操作，就需要获取sessionFactory，而这个sessionFactory的获取我们采用spring的依赖注入方式，只需要在实现类中配置这个sessionFactory属性即可。
     * 1. Spring推荐使用sessionFactory的getCurrentSession()来获取Session，
     * 然后通过Session进行持久化操作。 ==> BaseDaoHibernate4.java
     * 
     * 2. Spring并不推荐使用HibernateTemplate、HibernateDaoSupport来实现Dao组件，
     * Spring4为了和以前编码风格兼容，才提供了HibernateTemplate、HibernateDaoSupport；
     * ==>==> BaseDaoHibernate3.java  

    1. package org.crazyit.common.dao.impl;
    3. import org.hibernate.*;
    5. import java.util.List;
    6. import java.io.Serializable;
    8. import org.crazyit.common.dao.*;
    9. /***********************************
    10.  * 1. Spring推荐使用sessionFactory的getCurrentSession()来获取Session，
    11.  * 然后通过Session进行持久化操作。 ==> BaseDaoHibernate4.java
    12.  * 
    13.  * 2. Spring并不推荐使用HibernateTemplate、HibernateDaoSupport来实现Dao组件，
    14.  * Spring4为了和以前编码风格兼容，才提供了HibernateTemplate、HibernateDaoSupport；
    15.  * ==>==> BaseDaoHibernate3.java
    16.  * 
    17. ***********************************/
    18. public class BaseDaoHibernate4<T> implements BaseDao<T>
    19. {
    20. 	// DAO组件进行持久化操作底层依赖的SessionFactory组件
    21. 	private SessionFactory sessionFactory;
    22. 	
    23. 	// 依赖注入SessionFactory所需的setter方法
    24. 	public void setSessionFactory(SessionFactory sessionFactory)
    25. 	{
    26. 		this.sessionFactory = sessionFactory;
    27. 	}
    28. 	public SessionFactory getSessionFactory()
    29. 	{
    30. 		return this.sessionFactory;
    31. 	}
    32. 	
    33. 	// 根据ID加载实体
    34. 	@SuppressWarnings("unchecked")
    35. 	public T get(Class<T> entityClazz , Serializable id)
    36. 	{
    37. 		return (T)getSessionFactory().getCurrentSession()
    38. 			.get(entityClazz , id);
    39. 	}
    40. 	// 保存实体
    41. 	public Serializable save(T entity)
    42. 	{
    43. 		return getSessionFactory().getCurrentSession()
    44. 			.save(entity);
    45. 	}
    46. 	// 更新实体
    47. 	public void update(T entity)
    48. 	{
    49. 		getSessionFactory().getCurrentSession().saveOrUpdate(entity);
    50. 	}
    51. 	// 删除实体
    52. 	public void delete(T entity)
    53. 	{
    54. 		getSessionFactory().getCurrentSession().delete(entity);
    55. 	}
    56. 	// 根据ID删除实体
    57. 	public void delete(Class<T> entityClazz , Serializable id)
    58. 	{
    59. 		getSessionFactory().getCurrentSession()
    60. 			.createQuery("delete " + entityClazz.getSimpleName()
    61. 				+ " en where en.id = ?0")
    62. 			.setParameter("0" , id)
    63. 			.executeUpdate();
    64. 	}
    65. 	// 获取所有实体
    66. 	public List<T> findAll(Class<T> entityClazz)
    67. 	{
    68. 		return find("select en from "
    69. 			+ entityClazz.getSimpleName() + " en");
    70. 	}
    71. 	
    72. 	// 获取实体总数
    73. 	public long findCount(Class<T> entityClazz)
    74. 	{
    75. 		List<?> l = find("select count(*) from "
    76. 			+ entityClazz.getSimpleName());
    77. 		// 返回查询得到的实体总数
    78. 		if (l != null && l.size() == 1 )
    79. 		{
    80. 			return (Long)l.get(0);
    81. 		}
    82. 		return 0;
    83. 	}
    85. 	// 根据HQL语句查询实体
    86. 	@SuppressWarnings("unchecked")
    87. 	protected List<T> find(String hql)
    88. 	{
    89. 		return (List<T>)getSessionFactory().getCurrentSession()
    90. 			.createQuery(hql)
    91. 			.list();
    92. 	}
    93. 	
    94. 	// 根据带占位符参数HQL语句查询实体
    95. 	@SuppressWarnings("unchecked")
    96. 	protected List<T> find(String hql , Object... params)
    97. 	{
    98. 		// 创建查询
    99. 		Query query = getSessionFactory().getCurrentSession()
    100. 			.createQuery(hql);
    101. 		// 为包含占位符的HQL语句设置参数
    102. 		for(int i = 0 , len = params.length ; i < len ; i++)
    103. 		{
    104. 			query.setParameter(i + "" , params[i]);
    105. 		}
    106. 		return (List<T>)query.list();
    107. 	}
    108. 	
    109. 	/**
    110. 	 * 使用hql 语句进行分页查询操作
    111. 	 * @param hql 需要查询的hql语句
    112. 	 * @param pageNo 查询第pageNo页的记录
    113. 	 * @param pageSize 每页需要显示的记录数
    114. 	 * @return 当前页的所有记录
    115. 	 */
    116. 	@SuppressWarnings("unchecked")
    117. 	protected List<T> findByPage(String hql,
    118. 		 int pageNo, int pageSize)
    119. 	{
    120. 		// 创建查询
    121. 		return getSessionFactory().getCurrentSession()
    122. 			.createQuery(hql)
    123. 			// 执行分页
    124. 			.setFirstResult((pageNo - 1) * pageSize)
    125. 			.setMaxResults(pageSize)
    126. 			.list();
    127. 	}
    128. 	
    129. 	/**
    130. 	 * 使用hql 语句进行分页查询操作
    131. 	 * @param hql 需要查询的hql语句
    132. 	 * @param params 如果hql带占位符参数，params用于传入占位符参数
    133. 	 * @param pageNo 查询第pageNo页的记录
    134. 	 * @param pageSize 每页需要显示的记录数
    135. 	 * @return 当前页的所有记录
    136. 	 */
    137. 	@SuppressWarnings("unchecked")
    138. 	protected List<T> findByPage(String hql , int pageNo, int pageSize
    139. 		, Object... params)
    140. 	{
    141. 		// 创建查询
    142. 		Query query = getSessionFactory().getCurrentSession()
    143. 			.createQuery(hql);
    144. 		// 为包含占位符的HQL语句设置参数
    145. 		for(int i = 0 , len = params.length ; i < len ; i++)
    146. 		{
    147. 			query.setParameter(i + "" , params[i]);
    148. 		}
    149. 		// 执行分页，并返回查询结果
    150. 		return query.setFirstResult((pageNo - 1) * pageSize)
    151. 			.setMaxResults(pageSize)
    152. 			.list();
    153. 	}
    154. }

    上面介绍的是Hibernate4推荐使用的方式，当然，我们也可以使用HibernateTemplete和HibernateDaoSupport来实现这个基类，这种方式主要是Hibernate3使用的方式，现在不推荐。
    HibernateTemplete是spring提供的模板，这里面封装好了基本的数据库操作方法。
    HibernateDaoSupport提供了两个方法：
    1. getHibernateTemplate()：获取HibernateTemplate，通过HibernateTemplate来实现数据库操作；
    2. setSessionFactory()：使用spring的依赖注入；
    BaseDaoHibernate3.java

    1. package org.crazyit.common.dao.impl;
    3. import java.io.Serializable;
    4. import java.util.List;
    6. import org.crazyit.common.dao.BaseDao;
    7. import org.hibernate.*;
    8. import org.springframework.orm.hibernate4.support.HibernateDaoSupport;
    9. import org.springframework.orm.hibernate4.HibernateCallback;
    10. /***********************************
    11.  * 1. Spring推荐使用sessionFactory的getCurrentSession()来获取Session，
    12.  * 然后通过Session进行持久化操作。 ==> BaseDaoHibernate4.java
    13.  * 
    14.  * 2. Spring并不推荐使用HibernateTemplate、HibernateDaoSupport来实现Dao组件，
    15.  * Spring4为了和以前编码风格兼容，才提供了HibernateTemplate、HibernateDaoSupport；
    16.  * ==>==> BaseDaoHibernate3.java
    17.  * 
    18. ***********************************/
    19. public class BaseDaoHibernate3<T> extends HibernateDaoSupport
    20. 	implements BaseDao<T>
    21. {
    22. 	// 根据ID加载实体
    23. 	public T get(Class<T> entityClazz, Serializable id)
    24. 	{
    25. 		return getHibernateTemplate().get(entityClazz, id);
    26. 	}
    28. 	// 保存实体
    29. 	public Serializable save(T entity)
    30. 	{
    31. 		return getHibernateTemplate().save(entity);
    32. 	}
    34. 	// 更新实体
    35. 	public void update(T entity)
    36. 	{
    37. 		getHibernateTemplate().saveOrUpdate(entity);
    38. 	}
    40. 	// 删除实体
    41. 	public void delete(T entity)
    42. 	{
    43. 		getHibernateTemplate().delete(entity);
    44. 	}
    46. 	// 根据ID删除实体
    47. 	public void delete(Class<T> entityClazz, Serializable id)
    48. 	{
    49. 		delete(get(entityClazz , id));
    50. 	}
    52. 	@Override
    53. 	@SuppressWarnings("unchecked")
    54. 	public List<T> findAll(Class<T> entityClazz)
    55. 	{
    56. 		return (List<T>)getHibernateTemplate().find("select en from "
    57. 			+ entityClazz.getSimpleName() + " en");
    58. 	}
    60. 	@Override
    61. 	@SuppressWarnings("unchecked")
    62. 	public long findCount(Class<T> entityClazz)
    63. 	{
    64. 		List<Long> list = (List<Long>)getHibernateTemplate().find(
    65. 			"select count(*) from " + entityClazz.getSimpleName() + " en");
    66. 		return list.get(0);
    67. 	}
    68. 	
    69. 	/**
    70. 	 * 使用hql 语句进行分页查询操作
    71. 	 * @param hql 需要查询的hql语句
    72. 	 * @param pageNo 查询第pageNo页的记录
    73. 	 * @param pageSize 每页需要显示的记录数
    74. 	 * @return 当前页的所有记录
    75. 	 */
    76. 	@SuppressWarnings("unchecked")
    77. 	protected List<T> findByPage(final String hql,
    78. 		final int pageNo, final int pageSize)
    79. 	{
    80. 		// 通过一个HibernateCallback对象来执行查询
    81. 		List<T> list = getHibernateTemplate()
    82. 			.execute(new HibernateCallback<List<T>>(){
    83. 			// 实现HibernateCallback接口必须实现的方法
    84. 			public List<T> doInHibernate(Session session)
    85. 			{
    86. 				// 执行Hibernate分页查询
    87. 				List<T> result = session.createQuery(hql)
    88. 					.setFirstResult((pageNo - 1) * pageSize)
    89. 					.setMaxResults(pageSize)
    90. 					.list();
    91. 				return result;
    92. 			}
    93. 		});
    94. 		return list;
    95. 	}
    97. 	/**
    98. 	 * 使用hql 语句进行分页查询操作
    99. 	 * @param hql 需要查询的hql语句
    100. 	 * @param pageNo 查询第pageNo页的记录
    101. 	 * @param pageSize 每页需要显示的记录数
    102. 	 * @param params 如果hql带占位符参数，params用于传入占位符参数
    103. 	 * @return 当前页的所有记录
    104. 	 */
    105. 	@SuppressWarnings("unchecked")
    106. 	protected List<T> findByPage(final String hql , final int pageNo, 
    107. 		final int pageSize , final  Object... params)
    108. 	{
    109. 		// 通过一个HibernateCallback对象来执行查询
    110. 		List<T> list = getHibernateTemplate()
    111. 			.execute(new HibernateCallback<List<T>>()
    112. 		{
    113. 			// 实现HibernateCallback接口必须实现的方法
    114. 			public List<T> doInHibernate(Session session)
    115. 			{
    116. 				// 执行Hibernate分页查询
    117. 				Query query = session.createQuery(hql);
    118. 				// 为包含占位符的HQL语句设置参数
    119. 				for(int i = 0 , len = params.length ; i < len ; i++)
    120. 				{
    121. 					query.setParameter(i + "" , params[i]);
    122. 				}
    123. 				List<T> result = query.setFirstResult((pageNo - 1) * pageSize)
    124. 					.setMaxResults(pageSize)
    125. 					.list();
    126. 				return result;
    127. 			}
    128. 		});
    129. 		return list;
    130. 	}
    131. }

    6.2 dao层具体类的实现

    这是BookDao的接口和实现类；

    我们需要让BookDao继承BaseDao，让BookDaoHibernate4类继承BaseDaoHibernate4；如下图所示：

    接口：BookDao.java
    1. package org.crazyit.booksys.dao;
    3. import org.crazyit.booksys.domain.Book;
    4. import org.crazyit.common.dao.BaseDao;
    6. public interface BookDao extends BaseDao<Book>
    7. {
    8. }
    1. package org.crazyit.booksys.dao.impl;
    3. import org.crazyit.booksys.dao.BookDao;
    4. import org.crazyit.booksys.domain.Book;
    5. import org.crazyit.common.dao.impl.BaseDaoHibernate4;
    6. /**
    7.  * Spring推荐使用继承前面的BaseDaoHibernate4，也可以继承前面的BaseDaoHibernate3
    8.  */
    9. public class BookDaoHibernate4 extends BaseDaoHibernate4<Book>
    10. 	implements BookDao{
    11. }
    对应的spring配置==>依赖注入：sessionFactory；

    BookDaoHibernate4继承了BaseDaoHibernate4，而BaseDaoHibernate4有SessionFactory属性；

    7. 持久层类的编写
    Book.java：为持久层类，与数据表相对应；
    1. package org.crazyit.booksys.domain;
    3. import javax.persistence.*;
    5. @Entity
    6. @Table(name="book_inf")
    7. public class Book
    8. {
    9. 	@Id @Column(name="book_id")
    10. 	@GeneratedValue(strategy=GenerationType.IDENTITY)
    11. 	private Integer id;
    12. 	
    13. 	@Column(name="book_name")
    14. 	private String name;
    15. 	
    16. 	private double price;
    17. 	
    18. 	private String author;
    19. 	
    20. 	public Integer getId()
    21. 	{
    22. 		return id;
    23. 	}
    24. 	public void setId(Integer id)
    25. 	{
    26. 		this.id = id;
    27. 	}
    28. 	public String getName()
    29. 	{
    30. 		return name;
    31. 	}
    32. 	public void setName(String name)
    33. 	{
    34. 		this.name = name;
    35. 	}
    36. 	public double getPrice()
    37. 	{
    38. 		return price;
    39. 	}
    40. 	public void setPrice(double price)
    41. 	{
    42. 		this.price = price;
    43. 	}
    44. 	public String getAuthor()
    45. 	{
    46. 		return author;
    47. 	}
    48. 	public void setAuthor(String author)
    49. 	{
    50. 		this.author = author;
    51. 	}
    52. }
    因为我们在spring的配置文件中配置了：
    而Book类又添加了注解：

    所以，spring容器会自动将book类看作是持久化类；
    与此同时，我们还在spring配置文件中配置了：hibernate.hbm2ddl.auto=update

    所以当我们第一次运行程序，执行数据库操作时，会在数据库中自动生成数据表：




    8. 控制层和业务层

    控制层：BookAction.java
    1. package org.crazyit.booksys.action;
    3. import java.util.List;
    5. import org.crazyit.booksys.domain.Book;
    6. import org.crazyit.booksys.service.BookService;
    8. import com.opensymphony.xwork2.ActionSupport;
    10. public class BookAction extends ActionSupport
    11. {
    12. 	private BookService bookService; //业务层组件
    13. 	private Book book;
    14. 	private List<Book> books;
    15. 	private int id;
    16. 	
    17. 	
    18. 	// 处理添加图书的add()方法
    19. 	public String add()
    20. 	{
    21. 		if(book == null){
    22. 			book = new Book();
    23. 			book.setAuthor("zhangsan");
    24. 			book.setName("zhangsan");
    25. 			book.setPrice(123);
    26. 		}
    27. 		// 调用业务逻辑组件的addBook()方法来处理用户请求		
    28. 		int result = bookService.addBook(book);
    29. 		if(result > 0)
    30. 		{
    31. 			addActionMessage("恭喜您，图书添加成功！");
    32. 			return SUCCESS;
    33. 		}
    34. 		addActionError("图书添加失败，请重新输入！");
    35. 		return ERROR;
    36. 	}
    37. 	
    38. 	public String list()
    39. 	{
    40. 		setBooks(bookService.getAllBooks());
    41. 		return SUCCESS;
    42. 	}
    43. 	public String delete()
    44. 	{
    45. 		bookService.deleteBook(id);
    46. 		return SUCCESS;
    47. 	}
    48. 	
    49. 	public void setBookService(BookService bookService)
    50. 	{
    51. 		this.bookService = bookService;
    52. 	}
    53. 	
    54. 	public Book getBook()
    55. 	{
    56. 		return book;
    57. 	}
    58. 	public void setBook(Book book)
    59. 	{
    60. 		this.book = book;
    61. 	}
    62. 	
    63. 	public List<Book> getBooks()
    64. 	{
    65. 		return books;
    66. 	}
    67. 	public void setBooks(List<Book> books)
    68. 	{
    69. 		this.books = books;
    70. 	}
    71. 	
    72. 	public int getId()
    73. 	{
    74. 		return id;
    75. 	}
    76. 	public void setId(int id)
    77. 	{
    78. 		this.id = id;
    79. 	}
    80. }
    bookService 采用依赖注入的方式：
     

    业务层：

    1. package org.crazyit.booksys.service;
    3. import java.util.List;
    5. import org.crazyit.booksys.domain.Book;
    7. public interface BookService
    8. {
    9. 	// 添加图书
    10. 	int addBook(Book book);
    12. 	List<Book> getAllBooks();
    13. 	
    14. 	void deleteBook(int id);
    15. }
    实现类：BookServiceImpl.java
    1. package org.crazyit.booksys.service.impl;
    3. import java.util.List;
    5. import org.crazyit.booksys.dao.BookDao;
    6. import org.crazyit.booksys.domain.Book;
    7. import org.crazyit.booksys.service.BookService;
    9. public class BookServiceImpl implements BookService
    10. {
    11. 	private BookDao bookDao;
    12. 	
    13. 	public void setBookDao(BookDao bookDao)
    14. 	{
    15. 		this.bookDao = bookDao;
    16. 	}
    18. 	@Override
    19. 	public int addBook(Book book)
    20. 	{
    21. 		return (Integer) bookDao.save(book);
    22. 	}
    24. 	@Override
    25. 	public List<Book> getAllBooks()
    26. 	{
    27. 		return bookDao.findAll(Book.class);
    28. 	}
    30. 	@Override
    31. 	public void deleteBook(int id)
    32. 	{
    33. 		bookDao.delete(Book.class, id);
    34. 	}
    35. }


    9. 前台界面

    bookForm.jsp
    2. <%@ page contentType="text/html; charset=GBK" language="java" errorPage="" %>
    3. <%@taglib prefix="s" uri="/struts-tags"%>
    4. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    5. 	"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
    6. <html xmlns="http://www.w3.org/1999/xhtml">
    7. <head>
    8. 	<title>添加图书</title>
    9. </head>
    10. <body>
    11. <h3>添加图书</h3>
    12. <s:form action="addBook">
    13. 	<s:textfield name="book.name" label="书名"/>
    14. 	<s:textfield name="book.price" label="价格"/>
    15. 	<s:textfield name="book.author" label="作者"/>
    16. 	<tr align="center">
    17. 		<td colspan="2">
    18. 		<s:submit value="添加" theme="simple"/>
    19. 		<s:reset value="重设" theme="simple"/>
    20. 		</td>
    21. 	</tr>
    22. </s:form>
    23. </body>
    24. </html>
    listBooks.jsp
    2. <%@ page contentType="text/html; charset=GBK" language="java" errorPage="" %>
    3. <%@taglib prefix="s" uri="/struts-tags"%>
    4. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    5. 	"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
    6. <html xmlns="http://www.w3.org/1999/xhtml">
    7. <head>
    8. 	<title>全部图书</title>
    9. </head>
    10. <body>
    11. <h3>全部图书</h3>
    12. <table width="640" border="1">
    13. 	<s:iterator value="books" var="b">
    14. 		<tr>
    15. 			<td><s:property value="name"/></td>
    16. 			<td><s:property value="price"/></td>
    17. 			<td><s:property value="author"/></td>
    18. 			<td><a href="${pageContext.request.contextPath}/deleteBook?id=${b.id}">删除</a></td>
    19. 		</tr>
    20. 	</s:iterator>
    21. </table>
    22. </body>
    23. </html>

    10.运行





    附件
    数据库文件
    1. /*
    2. Navicat MySQL Data Transfer
    4. Source Server         : default
    5. Source Server Version : 50626
    6. Source Host           : localhost:3306
    7. Source Database       : sampledb
    9. Target Server Type    : MYSQL
    10. Target Server Version : 50626
    11. File Encoding         : 65001
    13. Date: 2015-09-08 10:36:58
    14. */
    16. SET FOREIGN_KEY_CHECKS=0;
    18. -- ----------------------------
    19. -- Table structure for book_inf
    20. -- ----------------------------
    21. DROP TABLE IF EXISTS `book_inf`;
    22. CREATE TABLE `book_inf` (
    23.   `book_id` int(11) NOT NULL AUTO_INCREMENT,
    24.   `author` varchar(255) DEFAULT NULL,
    25.   `book_name` varchar(255) DEFAULT NULL,
    26.   `price` double NOT NULL,
    27.   PRIMARY KEY (`book_id`)
    28. ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    30. -- ----------------------------
    31. -- Records of book_inf
    32. -- ----------------------------
    34. -- ----------------------------
    35. -- Table structure for t_login_log
    36. -- ----------------------------
    37. DROP TABLE IF EXISTS `t_login_log`;
    38. CREATE TABLE `t_login_log` (
    39.   `login_log_id` int(11) NOT NULL AUTO_INCREMENT,
    40.   `user_id` int(11) DEFAULT NULL,
    41.   `ip` varchar(23) DEFAULT NULL,
    42.   `login_datetime` datetime DEFAULT NULL,
    43.   PRIMARY KEY (`login_log_id`)
    44. ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    46. -- ----------------------------
    47. -- Records of t_login_log
    48. -- ----------------------------
    50. -- ----------------------------
    51. -- Table structure for t_user
    52. -- ----------------------------
    53. DROP TABLE IF EXISTS `t_user`;
    54. CREATE TABLE `t_user` (
    55.   `user_id` int(11) NOT NULL AUTO_INCREMENT,
    56.   `user_name` varchar(30) DEFAULT NULL COMMENT '用户名',
    57.   `credits` int(11) DEFAULT NULL,
    58.   `password` varchar(32) DEFAULT NULL,
    59.   `last_visit` datetime DEFAULT NULL,
    60.   `last_ip` varchar(23) DEFAULT NULL,
    61.   PRIMARY KEY (`user_id`)
    62. ) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;
    64. -- ----------------------------
    65. -- Records of t_user
    66. -- ----------------------------
    67. INSERT INTO `t_user` VALUES ('1', 'admin', null, '123456', null, null);
    68. INSERT INTO `t_user` VALUES ('2', 'zpp', null, '888888', null, null);





    附件列表
    • 相关阅读:
      FZU 2150 Fire Game （高姿势bfs--两个起点）（路径不重叠：一个队列同时跑）
      HDU1010 Tempter of the Bone【小狗是否能逃生----DFS奇偶剪枝（t时刻恰好到达）】
      MySQL--9存储引擎
      MySQL--7MySQL自定义函数
      MySQL--5子查询与连接小结
      MySQL--4操作数据表中的记录小结
      MySQL--6运算符和函数小结
      MySQL--8MySQL存储过程小结
      Hybrid设计--如何落地一个Hybrid项目
      Hybrid设计--离线更新
    • 原文地址：https://www.cnblogs.com/ssslinppp/p/4540265.html
    Copyright © 2011-2022 走看看