Struts2.1.6 +Spring2.5.6 + Hibernate3.3.2
1. 需要的jar包列表
jar包名称 | 所在位置 | 说明 |
antlr-2.7.6.jar | hibernate/lib/required | 解析HQL |
aspectjrt | spring/lib/aspectj | AOP |
aspectjweaver | .. | AOP |
cglib-nodep-2.1_3.jar | spring/lib/cglib | 代理，二进制增强 |
common-annotations.jar | spring/lib/j2ee | @Resource |
commons-collections-3.1.jar | hibernate/lib/required | 集合框架 |
commons-fileupload-1.2.1.jar | struts/lib | struts |
commons-io-1.3.2 | struts/lib | struts |
commons-logging-1.1.1 | 单独下载，删除1.0.4(struts/lib) | struts spring |
dom4j-1.6.1.jar | hibernate/required | 解析xml |
ejb3-persistence | hibernate-annotation/lib | @Entity |
freemarker-2.3.13 | struts/lib | struts |
hibernate3.jar | hibernate |
|
hibernate-annotations | hibernate-annotation/ |
|
hibernate-common-annotations | hibernate-annotation/lib |
|
javassist-3.9.0.GA.jar | hiberante/lib/required | hibernate |
jta-1.1.jar | .. | hibernate transaction |
junit4.5 |
|
|
mysql- |
|
|
ognl-2.6.11.jar | struts/lib |
|
slf4j-api-1.5.8.jar | hibernate/lib/required | hibernate-log |
slf4j-nop-1.5.8.jar | hibernate/lib/required |
|
spring.jar | spring/dist |
|
struts2-core-2.1.6.jar | struts/lib |
|
xwork-2.1.2.jar | struts/lib | struts2 |
commons-dbcp | spring/lib/jarkata-commons |
|
commons-pool.jar | .. |
|
struts2-spring-plugin-2.1.6.jar | struts/lib |
|
|
|
|
2. BestPractice：
a) 将这些所有的jar包保存到一个位置，使用的时候直接copy
3. 步骤
a) 加入jar包
b) 首先整合Spring + Hibernate
i. 建立对应的package
1. dao / dao.impl / model / service / service.impl/ test
ii. 建立对应的接口与类框架
1. S2SH_01
iii. 建立spring的配置文件（建议自己保留一份经常使用的配置文件，以后用到的时候直接copy改）
iv. 建立数据库
v. 加入Hibernate注解
1. 在实体类上加相应注解@Entity @Id等
2. 在beans配置文件配置对应的实体类，使之受管
vi. 写dao service的实现
vii. 加入Spring注解
1. 在对应Service及DAO实现中加入@Component，让spring对其初始化
2. 在Service上加入@Transactional或者使用xml方式（此处建议后者，因为更简单）
3. 在DAO中注入sessionFactory
4. 在Service中注入DAO
5. 写DAO与Service的实现
viii. 写测试
c) 整合Struts2
i. 结合点：Struts2的Action由Spring产生
ii. 步骤：
1. 修改web.xml加入 struts的filter
2. 再加入spring的listener，这样的话，webapp一旦启动，spring容器就初始化了
3. 规划struts的action和jsp展现
4. 加入struts.xml
a) 修改配置，由spring替代struts产生Action对象
5. 修改action配置
a) 把类名改为bean对象的名称，这个时候就可以使用首字母小写了
b) @Scope(“prototype”)不要忘记
iii. struts的读常量：
1. struts-default.xml
2. struts-plugin.xml
3. struts.xml
4. struts.properties
5. web.xml
iv. 中文问题：
1. Struts2.1.8已经修正，只需要改i18n.encoding = gbk
2. 使用spring的characterencoding
3. 需要严格注意filter的顺序
4. 需要加到Struts2的filter前面
v. LazyInitializationException
1. OpenSessionInViewFilter
2. 需要严格顺序问题
需要加到struts2的filter
_____________________________________________________________________________________________
pageEncoding 改成可以显示中文的GB18030
Spring_2300_Registration_1以下程序是jsp和数据打交道的一个登陆页面
register.jsp
registerDeal.jsp
registerFail.jsp
registerSuccess.jsp
1. <!-- register.jsp 登陆页面-->
2. <%@ page language="java" import="java.util.*" pageEncoding="GB18030"%>
3. <%
4. String path = request.getContextPath();
5. String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
6. %>
7. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
8. <html>
9. <head>
10. <base href="<%=basePath%>">
11. <title>用户注册</title>
12. </head>
13. <body>
14. <form action="registerDeal.jsp" method="post">
15. <input type="text" name="username"><br/>
16. <input type="password" name="password"><br/>
17. <input type="password" name="password2"><br/>
18. <input type="submit" value="提交">
19. <input type="reset" value="重置">
20. </form>
21. </body>
22. </html>
1. <!-- registerDeal.jsp -->
2. <%@ page language="java" import="java.util.*" pageEncoding="GB18030"%>
3. <%@ page import="java.sql.*" %>
4. <%
5. String path = request.getContextPath();
6. String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
7. String username = request.getParameter("username");
8. String password = request.getParameter("password");
9. String password2 = request.getParameter("password2");
10. Class.forName("com.mysql.jdbc.Driver");
11. Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/spring","root","root");
12.
13. //判断用户名是否存在
14. String sqlQuery = "select count(*) from user where username = ?";
15. PreparedStatement pstmQuery = conn.prepareStatement(sqlQuery);
16. pstmQuery.setString(1,username);
17. ResultSet rs = pstmQuery.executeQuery();
18. rs.next();
19. int count = rs.getInt(1);
20. if(count > 0) {
21. response.sendRedirect("registerFail.jsp");
22. pstmQuery.close();
23. conn.close();
24. return;
25. }
26.
27.
28. //在插入之前要检查用户名是否存在,不存在就插入
29. String sql = "insert into user values(null,?,?)";
30. PreparedStatement pstm = conn.prepareStatement(sql);
31. pstm.setString(1,username);
32. pstm.setString(2,password);
33. pstm.executeUpdate();
34. pstm.close();
35. conn.close();
36.
37. response.sendRedirect("registerSuccess.jsp");
38. %>
1. <p>用户注册得有个实体类吧 User</p><p><img src="" alt="" /></p><p>把jsp的业务逻辑封装在一个业务逻辑层</p><p><img src="" alt="" /></p><pre name="code" class="java">package com.demo.registration.service;
2.
3. import java.sql.Connection;
4. import java.sql.DriverManager;
5. import java.sql.PreparedStatement;
6. import java.sql.ResultSet;
7. import java.sql.SQLException;
8.
9. import com.demo.registration.model.User;
10.
11. public class UserManager {
12. //判断用户名是否存在
13. public boolean exists(User user) {
14. conn = null;
15. pstmQuery = null;
16. sqlQuery = "select count(*) from user where username = ?";
17.
18. try {
19. Class.forName("com.mysql.jdbc.Driver");
20. conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/spring","root","root");
21. pstmQuery = conn.prepareStatement(sqlQuery);
22. pstmQuery.setString(1,user.getUsername());
23. rs = pstmQuery.executeQuery();
24. count = 0;
25. while(rs.next()){
26. count = rs.getInt(1);
27. > 0) {
28. return true;
29. }
30. return false;
31. }
32.
33. } catch (ClassNotFoundException e) {
34. e.printStackTrace();
35. } catch (SQLException e) {
36. e.printStackTrace();
37. } finally {
38. if(pstmQuery != null) {
39. try {
40. pstmQuery.close();
41. pstmQuery = null;
42. } catch (Exception e2) {
43. e2.printStackTrace();
44. }
45.
46. }
47. if(conn != null) {
48. try {
49. conn.close();
50. conn = null;
51. } catch (Exception e2) {
52. e2.printStackTrace();
53. }
54. }
55. }
56. return false;
57. }
58. //在插入之前要检查用户名是否存在,不存在就插入
59. public void add(User user) {
60. conn = null;
61. pstm = null;
62. sql = "insert into user values(null,?,?)";
63. try {
64. Class.forName("com.mysql.jdbc.Driver");
65. conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/spring","root","root");
66. pstm = conn.prepareStatement(sql);
67. pstm.setString(1,user.getUsername());
68. pstm.setString(2, user.getPassword());
69. pstm.executeUpdate();
70.
71. } catch (ClassNotFoundException e) {
72. e.printStackTrace();
73. } catch (SQLException e) {
74. e.printStackTrace();
75. } finally {
76. if(pstm != null) {
77. try {
78. pstm.close();
79. pstm = null;
80. } catch (Exception e2) {
81. e2.printStackTrace();
82. }
83.
84. }
85. if(conn != null) {
86. try {
87. conn.close();
88. conn = null;
89. } catch (Exception e2) {
90. e2.printStackTrace();
91. }
92. }
93. }
94. }
95. } jsp直接调用UserManager类里面的业务逻辑即可
1. <!-- registerDeal.jsp -->
2. <%@ page language="java" import="java.util.*" pageEncoding="GB18030"%>
3. <%@ page import="java.sql.*" %>
4. <%@ page import="com.demo.registration.service.UserManager" %>
5. <%@page import="com.demo.registration.model.User"%>
6. <%
7. String path = request.getContextPath();
8. String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
9. String username = request.getParameter("username");
10. String password = request.getParameter("password");
11. String password2 = request.getParameter("password2");
12.
13. User user = new User();
14. user.setUsername(username);
15. user.setPassword(password);
16.
17. UserManager userManager = new UserManager();
18. boolean exists = userManager.exists(user);
19. if(exists) {
20. response.sendRedirect("registerFail.jsp");
21. return ;
22. }
23. userManager.add(user);
24. response.sendRedirect("registerSuccess.jsp");
25. %>项目在tomcat中的加载
加入hibernate 和数据库打交道 引入的准备工作：
1、引入jar包
2、搭建hibernate.cfg.xml ， log4j.properties 两个配置文件
3、引入junit 进行测试
1. package com.demo.registration.service;
2.
3. import java.sql.Connection;
4. import java.sql.DriverManager;
5. import java.sql.PreparedStatement;
6. import java.sql.ResultSet;
7. import java.sql.SQLException;
8.
9. import org.hibernate.Session;
10. import org.hibernate.SessionFactory;
11.
12. import com.demo.registration.model.User;
13. import com.demo.registration.util.HibernateUtil;
14.
15. public class UserManager {
16. //判断用户名是否存在
17.
18.
19. public boolean exists(User user) {
20. SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
21. Session session = sessionFactory.getCurrentSession();
22. session.beginTransaction();
23.
24. "select count(*) from User u where u.username = :username")
25. "username", user.getUsername())
26. .uniqueResult();
27. session.getTransaction().commit();
28.
29. if(count > 0) return true;
30. return false;
31. }
32. //在插入之前要检查用户名是否存在,不存在就插入
33. public void add(User user) {
34. SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
35. Session session = sessionFactory.getCurrentSession();
36. session.beginTransaction();
37. session.save(user);
38. session.getTransaction().commit();
39. }
40. }
1. //Junit测试类
2. package com.demo.registration.service;
3.
4. import org.junit.Assert; //自动提示
5.
6. import org.junit.Test;
7.
8. import com.demo.registration.model.User;
9.
10. public class UserManagerTest {
11.
12. @Test
13. public void testExists() {
14. new UserManager();
15. new User();
16. "a");
17. boolean exists = userManager.exists(user);
18. true, exists);
19. }
20.
21. @Test
22. public void testAdd() throws Exception {
23. new UserManager();
24. new User();
25. "o");
26. "o");
27. boolean exists = userManager.exists(user);
28. if(!exists) {
29. userManager.add(user);
30. "o");
31. true, userManager.exists(user));
32. else {
33. "not added");
34. }
35. }
36.
37. }
抽象DAO层，咋们考虑另一种客户端，不通过自己的逻辑，就想直接访问数据库里面的内容，所以我们把DAO层抽象出来，不要直接把数据库这张表暴露给它，保证安全。
假如，要跨数据库的实现，要跨各种各样的存储方式来实现，不只是包括Hibernate去访问数据库，还要包括：如把User存在xml文件里，把User存在网络上去。 因此UserManager不要把
User的存储最好不要写死，写死成Hibernate、写成JDBC或者xml。
所以这个时候就需要DAO层（专门用来封装对实体类的数据库的访问，就是增删改查，不加业务逻辑）。
UserDao层
UserDAOImpl实现层
UserManagerImple实现层
根据一个实现类抽取接口的方法
1. package com.demo.registration.service;
2.
3. import com.demo.registration.model.User;
4.
5. public interface UserManager {
6.
7. public abstract boolean exists(User user) throws Exception;
8.
9. public abstract void add(User user) throws Exception;
10.
11. }
1. package com.demo.registration.service.impl;
2.
3.
4. import com.demo.registration.dao.UserDao;
5. import com.demo.registration.dao.impl.UserDaoImpl;
6. import com.demo.registration.model.User;
7. import com.demo.registration.service.UserManager;
8.
9. public class UserManagerImpl implements UserManager {
10. new UserDaoImpl();
11.
12. public UserDao getUserDao() {
13. return userDao;
14. }
15.
16. public void setUserDao(UserDao userDao) {
17. this.userDao = userDao;
18. }
19.
20. public boolean exists(User user) {
21. return userDao.checkUserExistsWithName(user.getUsername());
22. }
23.
24. public void add(User user) {
25. userDao.save(user);
26. }
27.
28.
29. }struts2 解决了容器Cotroller （控制器）
1、把view （V）层和 业务逻辑层（M）分开
2、view也可以进行重复使用，也可以进行替换，也可以进行扩展 （其实只是把view 起了个名，想把实现文件替换掉，只需要该配置文件即可）
3、（M）业务逻辑层 也可以进行重复使用，也可以进行扩展
4、主要解决互相之间耦合性不那么强的依赖于对方
struts 这一层准备工作：
1、引入jar包
2、web.xml 里面进行filter的配置
3、把struts.xml 引入进来
4、建立action
1. //struts.xml
2. <?xml version="1.0" encoding="UTF-8" ?>
3. <!DOCTYPE struts PUBLIC
4. "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
5. >
6.
7. <struts>
8. <constant name="struts.devMode" value="true"/>
9.
10. <package name="registration" extends="struts-default">
11. <action name="user" class="com.demo.registration.action.UserAction">
12. <result name="success">/registerSuccess.jsp</result>
13. <result name="fail">/registerFail.jsp</result>
14. </action>
15. </package>
16.
17.
18. </struts>
1. web.xml
2.
3. <filter>
4. <filter-name>struts2</filter-name>
5. <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
6. </filter>
7.
8. <filter-mapping>
9. <filter-name>struts2</filter-name>
10. <url-pattern>/*</url-pattern>
11. </filter-mapping>
1. package com.demo.registration.action;
2.
3. import com.demo.registration.model.User;
4. import com.demo.registration.service.UserManager;
5. import com.demo.registration.service.impl.UserManagerImpl;
6. import com.opensymphony.xwork2.ActionSupport;
7.
8. public class UserAction extends ActionSupport {
9. private String username;
10. private String password;
11. private String password2;
12.
13.
14. new UserManagerImpl();
15.
16. public UserManager getUserManager() {
17. return userManager;
18. }
19.
20. public void setUserManager(UserManager userManager) {
21. this.userManager = userManager;
22. }
23.
24. @Override
25. public String execute() throws Exception {
26. new User();
27. user.setUsername(username);
28. user.setPassword(password);
29. if(userManager.exists(user)) {
30. return "fail";
31. }
32. userManager.add(user);
33. return "success";
34. }
35.
36. public String getUsername() {
37. return username;
38. }
39.
40. public void setUsername(String username) {
41. this.username = username;
42. }
43.
44. public String getPassword() {
45. return password;
46. }
47.
48. public void setPassword(String password) {
49. this.password = password;
50. }
51.
52. public String getPassword2() {
53. return password2;
54. }
55.
56. public void setPassword2(String password2) {
57. this.password2 = password2;
58. }
59. }
spring 加入
需要的配置
1、加入jar包
2、 beans.xml 、 log4j.properties
3、hibernate数据连接的配置已经在beans.xml里面 因此 hibernate.cfg.xml 可以删除了
业务分析
1、当UserManager 去拿UserDao的时候是spring帮你注入的
2、UserManager本身也是由spring来管理的
3、Action要用UserManager的时候也是由spring帮我注入的
4、UserManager里面的方法它都会帮你加上AOP
1. <listener>
2. <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
3. </listener> listener的作用：
就是我们当前的Application启动，它就启动，listener启动之后就去找我们的配置文件，就把我们配置文件里面的对象全部都初始化出来，容器就产生了。
1. // 对beans.xml 所有配置的说明
2. <?xml version="1.0" encoding="UTF-8"?>
3. <beans xmlns="http://www.springframework.org/schema/beans"
4. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
5. xmlns:context="http://www.springframework.org/schema/context"
6. xmlns:aop="http://www.springframework.org/schema/aop"
7. xmlns:tx="http://www.springframework.org/schema/tx"
8. xsi:schemaLocation="http://www.springframework.org/schema/beans
9. http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
10. http://www.springframework.org/schema/context
11. http://www.springframework.org/schema/context/spring-context-2.5.xsd
12. http://www.springframework.org/schema/aop
13. http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
14. http://www.springframework.org/schema/tx
15. >
16.
17. <context:annotation-config />
18. <!-- 扫描所有 com.demo包下面类中所有的组件和注入的资源Component Resource -->
19. <context:component-scan base-package="com.demo"/>
20.
21. <!--
22. <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
23. <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
24. <property name="url" value="jdbc:mysql://localhost:3306/spring"/>
25. <property name="username" value="root"/>
26. <property name="password" value="root"/>
27. </bean>
28. >
29.
30. <!-- 连接数据库 -->
31. <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
32. <property name="locations">
33. <value>classpath:jdbc.properties</value>
34. </property>
35. </bean>
36.
37. <bean id="dataSource" destroy-method="close"
38. class="org.apache.commons.dbcp.BasicDataSource">
39. <property name="driverClassName" value="${jdbc.driverClassName}"/>
40. <property name="url" value="${jdbc.url}"/>
41. <property name="username" value="${jdbc.username}"/>
42. <property name="password" value="${jdbc.password}"/>
43. </bean>
44.
45.
46. <!-- 通过数据库配置连接 -->
47. <bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
48. <property name="dataSource" ref="dataSource"/>
49. <!--
50. <property name="annotatedClasses">
51. <list>
52. <value>com.demo.model.User</value>
53. <value>com.demo.model.Log</value>
54. </list>
55. </property>
56. >
57. <!-- 实体类（用@Entity标注）的自动扫描 -->
58. <property name="packagesToScan">
59. <list>
60. <value>com.demo.registration.model</value>
61. </list>
62. </property>
63.
64. <property name="hibernateProperties">
65. <props>
66. <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
67. <prop key="hibernate.show_sql">true</prop>
68. </props>
69. </property>
70. </bean>
71.
72. <!-- 事物管理 HibernateTransactionManager 管理事务嵌套，开启，关闭，资源线程同步，提交，回滚 -->
73. <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
74. <property name="sessionFactory" ref="sessionFactory"/>
75. </bean>
76.
77. <aop:config>
78. <aop:pointcut id="bussinessService" expression="execution(public * com.demo.registration.service..*.*(..))"/>
79. <aop:advisor advice-ref="txAdvice" pointcut-ref="bussinessService"/>
80. </aop:config>
81. <!-- 在指定方法上面加事物 事物边界是放在service 这里，只有调用才会产生 -->
82. <tx:advice id="txAdvice" transaction-manager="txManager">
83. <tx:attributes>
84. <tx:method name="exists" read-only="true"/>
85. <tx:method name="add*" propagation="REQUIRED"/>
86. </tx:attributes>
87. </tx:advice>
88.
89. <!-- Hibernate的常规用法，就可完成大多数DAO对象的CRUD操作 也支持分页 -->
90. <bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
91. <property name="sessionFactory" ref="sessionFactory"></property>
92. </bean>
93.
94. </beans>
1. <listener>
2. <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
3. <!-- default: /WEB-INF/applicationContext.xml -->
4. </listener>
5.
6. <!-- Context Configuration locations for Spring XML files -->
7. <context-param>
8. <param-name>contextConfigLocation</param-name>
9. <!--<param-value>/WEB-INF/applicationContext-*.xml,classpath*:applicationContext-*.xml</param-value>-->
10. <param-value>classpath:beans.xml</param-value>
11. </context-param> 引入jar包 D:\javasoft\ssh\struts-2.1.6\lib\struts2-spring-plugin-2.1.6.jar
下面是struts2+hibernate+spring配置文件的一部分，以前都是仿造已经写好的bean的配置。有一次 scope="prototype"忘记写了结果出了问题
1. 项目中对一个表的增删该操作是用一个action，这个action有add,update,delete,save这些方法，添加和修改是共用一个页面，当页面得到id时代表进行的修改操作，反之是添加操作。因为在配置spring的bean是忘了写scope="prototype"所以每次添加时都显示最后一次访问过的记录
2. 找了很长时间，原来是spring bean出了问题。 scope="prototype" 会在该类型的对象被请求时创建一个新的action对象。如果没有配置scope=prototype则添加的时候不会新建一个action，他任然会保留上次访问的过记录的信息。
3. <bean id="assetAction" class="com.servicezone.itsd.asset.webapp.action.AssetAction" scope="prototype">
4. <property name="assetManager" ref="assetManager"/>
5. <property name="itProductManager" ref="itProductManager"/>
6. <property name="vendorManager" ref="vendorManager"/>
7. <property name="deptManager" ref="deptManager"/>
8. <property name="userManager" ref="userManager"/>
9. <property name="assetTypeManager" ref="assetTypeManager"/>
10. </bean>
1. /**
2. scope="prototype" 会在该类型的对象被请求时创建一个新的action对象。
3. scope=prototype则添加的时候不会新建一个action，
4. * 他任然会保留上次访问的过记录的信息。
5. */
1. //web.xml
2.
3. <?xml version="1.0" encoding="UTF-8"?>
4. <web-app version="2.5"
5. xmlns="http://java.sun.com/xml/ns/javaee"
6. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
7. xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
8. >
9. <welcome-file-list>
10. <welcome-file>index.jsp</welcome-file>
11. </welcome-file-list>
12.
13. <!-- 监听器 初始化所有的配置文件 -->
14.
15. <listener>
16. <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
17. <!-- default: /WEB-INF/applicationContext.xml -->
18. </listener>
19.
20. <!-- Context Configuration locations for Spring XML files -->
21. <context-param>
22. <param-name>contextConfigLocation</param-name>
23. <!--<param-value>/WEB-INF/applicationContext-*.xml,classpath*:applicationContext-*.xml</param-value>-->
24. <param-value>classpath:beans.xml</param-value>
25. </context-param>
26.
27.
28.
29.
30. <!-- struts的配置文件 -->
31.
32. <filter>
33. <filter-name>struts2</filter-name>
34. <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
35. </filter>
36.
37. <filter-mapping>
38. <filter-name>struts2</filter-name>
39. <url-pattern>/*</url-pattern>
40. </filter-mapping>
41. </web-app>
1. <?xml version="1.0" encoding="UTF-8" ?>
2. <!DOCTYPE struts PUBLIC
3. "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
4. >
5.
6. <struts>
7. <constant name="struts.devMode" value="true"/>
8.
9. <package name="registration" extends="struts-default">
10. <action name="user" class="com.demo.registration.action.UserAction">
11. <result name="success">/registerSuccess.jsp</result>
12. <result name="fail">/registerFail.jsp</result>
13. </action>
14. </package>
15.
16. </struts>ssh 整合视图
1. /**
2. scope="prototype" 会在该类型的对象被请求时创建一个新的action对象。
3. scope=prototype则添加的时候不会新建一个action，
4. * 他任然会保留上次访问的过记录的信息。
5. */
6.
7. @Component("user")
8. @Scope("prototype") // 每个请求都会生成一个新的action
再加DTO层
1. package com.demo.registration.vo;
2.
3. public class UserRegisterInfo {
4. private String username;
5. private String password;
6. private String password2;
7. public String getUsername() {
8. return username;
9. }
10. public void setUsername(String username) {
11. this.username = username;
12. }
13. public String getPassword() {
14. return password;
15. }
16. public void setPassword(String password) {
17. this.password = password;
18. }
19. public String getPassword2() {
20. return password2;
21. }
22. public void setPassword2(String password2) {
23. this.password2 = password2;
24. }
25.
26. }
1. package com.demo.registration.action;
2.
3. import javax.annotation.Resource;
4.
5. import org.springframework.context.ApplicationContext;
6. import org.springframework.context.annotation.Scope;
7. import org.springframework.context.support.ClassPathXmlApplicationContext;
8. import org.springframework.stereotype.Component;
9.
10. import com.demo.registration.model.User;
11. import com.demo.registration.service.UserManager;
12. import com.demo.registration.vo.UserRegisterInfo;
13. import com.opensymphony.xwork2.ActionSupport;
14. import com.opensymphony.xwork2.ModelDriven;
15.
16.
17. //1、action类中不要写annotation写了没用struts自己产生
18. // 2、spring可以注入
19. public class UserAction extends ActionSupport implements ModelDriven {
20.
21. private UserRegisterInfo info = new UserRegisterInfo();
22.
23. private UserManager userManager;
24.
25. public UserManager getUserManager() {
26. return userManager;
27. }
28.
29.
30. public void setUserManager(UserManager userManager) {
31. this.userManager = userManager;
32. }
33. @Override
34. public String execute() throws Exception {
35. new User();
36. user.setUsername(info.getUsername());
37. user.setPassword(info.getPassword());
38. if(userManager.exists(user)) {
39. return "fail";
40. }
41. userManager.add(user);
42. return "success";
43. }
44.
45. public UserRegisterInfo getInfo() {
46. return info;
47. }
48. public void setInfo(UserRegisterInfo info) {
49. this.info = info;
50. }
51.
52. @Override
53. public Object getModel() {
54. return info;
55. }
56. }
以下为MVC架构图形
mvc
因此分析如下：
1、界面原型，帮我们建立分析需求
2、确定实体类，建立数据库表
1. <s:debug></s:debug> 把开发模式设为 true
2.
3. <constant name="struts.devMode" value="true"/>
获取数据库里面的usernam
1. <body>
2. <s:iterator value="users"> <!-- UserAction 里面 private List<User> users; users属性 -->
3. <s:property value="username"></s:property> <!-- 封装在这个类里面UserRegisterInfo的username属性 -->
4. </s:iterator>
5. <s:debug></s:debug>
6. </body>
1. package com.demo.registration.action;
2.
3. import java.util.List;
4.
5. import javax.annotation.Resource;
6.
7. import org.springframework.context.ApplicationContext;
8. import org.springframework.context.annotation.Scope;
9. import org.springframework.context.support.ClassPathXmlApplicationContext;
10. import org.springframework.stereotype.Component;
11.
12. import com.demo.registration.model.User;
13. import com.demo.registration.service.UserManager;
14. import com.demo.registration.vo.UserRegisterInfo;
15. import com.opensymphony.xwork2.ActionSupport;
16. import com.opensymphony.xwork2.ModelDriven;
17.
18.
19.
20. public class UserAction extends ActionSupport implements ModelDriven {
21.
22. private UserRegisterInfo info = new UserRegisterInfo();
23.
24. private UserManager userManager;
25. private List<User> users;
26.
27. public UserManager getUserManager() {
28. return userManager;
29. }
30.
31. public void setUserManager(UserManager userManager) {
32. this.userManager = userManager;
33. }
34. public String list() {
35. this.users = this.userManager.getUsers();
36. return "list";
37. }
38.
39. @Override
40. public String execute() throws Exception {
41. new User();
42. user.setUsername(info.getUsername());
43. user.setPassword(info.getPassword());
44. if(userManager.exists(user)) {
45. return "fail";
46. }
47. userManager.add(user);
48. return "success";
49. }
50.
51. public UserRegisterInfo getInfo() {
52. return info;
53. }
54. public void setInfo(UserRegisterInfo info) {
55. this.info = info;
56. }
57.
58. @Override
59. public Object getModel() {
60. return info;
61. }
62.
63. public List<User> getUsers() {
64. return users;
65. }
66.
67. public void setUsers(List<User> users) {
68. this.users = users;
69. }
70. }1. /*
2. * 在测试load方法的时候因为是getCurrentSession load 完了就关闭
3. * 在web.xml里面配置 OpenSessionInViewFilter jsp关闭session才关闭不过要配置的
4. * StrutsPrepareAndExecuteFilter的前面
5. */
6.
7.
8.
9. public String load() {
10. thisthis.user = this.userManager.loadById(info.getId());
11. return "load";
12. }
1. // 以下是jsp获取属性的2中同样的方法
2. <!--
3.
4. <s:iterator value="user">
5. <s:property value="username"/>
6. </s:iterator>
7. >
8.
9. <s:property value="user.username"/>
1.
2. //以下配置文件作用是把Session 打开的时间一直延续到jsp这层，完了之后就关闭，不过单个对象可以用get方法(load) 如果没有配事物边界HibernateTransactionManager 那么它<pre name="code" class="html">//openSessionInView 认为这个session里面的这个事物是只读的，
<filter><filter-name>openSessionInView</filter-name><filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class></filter><filter-mapping> <filter-name>openSessionInView</filter-name> <url-pattern>/*</url-pattern> </filter-mapping>
1. <?xml version="1.0" encoding="UTF-8"?>
2. <web-app version="2.5"
3. xmlns="http://java.sun.com/xml/ns/javaee"
4. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
5. xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
6. >
7. <welcome-file-list>
8. <welcome-file>index.jsp</welcome-file>
9. </welcome-file-list>
10.
11.
12.
13. <listener>
14. <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
15. <!-- default: /WEB-INF/applicationContext.xml -->
16. </listener>
17.
18. <!-- Context Configuration locations for Spring XML files -->
19. <context-param>
20. <param-name>contextConfigLocation</param-name>
21. <!--<param-value>/WEB-INF/applicationContext-*.xml,classpath*:applicationContext-*.xml</param-value>-->
22. <param-value>classpath:beans.xml</param-value>
23. </context-param>
24.
25.
26.
27. <filter>
28. <filter-name>openSessionInView</filter-name>
29. <filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class>
30. </filter>
31. <filter-mapping>
32. <filter-name>openSessionInView</filter-name>
33. <url-pattern>/*</url-pattern>
34. </filter-mapping>
35.
36.
37.
38.
39.
40. <filter>
41. <filter-name>struts2</filter-name>
42. <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
43. </filter>
44.
45. <filter-mapping>
46. <filter-name>struts2</filter-name>
47. <url-pattern>/*</url-pattern>
48. </filter-mapping>
49.
50.
51.
52.
53. </web-app>
1. //查看mysql数据库表里面的编码
2.
3. mysql> show create table user;
4. +-------+----------------------------------
5. -------------------------------+
6. | Table | Create Table
7. |
8. +-------+----------------------------------
9. -------------------------------+
10. | user | CREATE TABLE `user` (
11. `id` int(11) NOT NULL AUTO_INCREMENT,
12. `username` varchar(100) DEFAULT NULL,
13. `password` varchar(20) DEFAULT NULL,
14. PRIMARY KEY (`id`)
15. ) ENGINE=InnoDB DEFAULT CHARSET=gb2312 |
16. +-------+----------------------------------
17. -------------------------------+
18. 1 row in set (0.05 sec)
1. 编码问题
2.
3. 1、如果是在action 往数据库里面插入产生的，那么就需要解决action与数据库之间的编码问题，数据库连接，数据库底层表的实现的编码
4.
5. 2、如果是接收参数产生的就是配置web方面产生的
1. <pre name="code" class="html">乱码问题解决 利用spring
web.xml配置 filter 乱码 <filter> <filter-name>encodingFilter</filter-name> <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class> <init-param> <param-name>encoding</param-name> <param-value>GBK</param-value> </init-param> </filter> <filter-mapping> <filter-name>encodingFilter</filter-name> <url-pattern>/*</url-pattern> </filter-mapping>1. package com.demo.registration.action;
2.
3. import java.util.List;
4.
5. import javax.annotation.Resource;
6.
7. import org.springframework.context.ApplicationContext;
8. import org.springframework.context.annotation.Scope;
9. import org.springframework.context.support.ClassPathXmlApplicationContext;
10. import org.springframework.stereotype.Component;
11.
12. import com.demo.registration.model.User;
13. import com.demo.registration.service.UserManager;
14. import com.demo.registration.vo.UserRegisterInfo;
15. import com.opensymphony.xwork2.ActionSupport;
16. import com.opensymphony.xwork2.ModelDriven;
17.
18. /**
19. * scope="prototype" 会在该类型的对象被请求时创建一个新的action对象。
20. * 如果没有配置scope=prototype则添加的时候不会新建一个action，
21. * 他任然会保留上次访问的过记录的信息。
22. */
23.
24.
25.
26. @Component("u") //这个与struts.xml配置里面的 calss一直
27. @Scope("prototype")// 每个请求都会生成一个新的action
28. public class UserAction extends ActionSupport implements ModelDriven {
29.
30. private UserRegisterInfo info = new UserRegisterInfo();
31.
32. private UserManager userManager;
33. private List<User> users;
34. private User user;
35.
36. public UserManager getUserManager() {
37. return userManager;
38. }
39. @Resource
40. public void setUserManager(UserManager userManager) {
41. this.userManager = userManager;
42. }
43. public String list() {
44. this.users = this.userManager.getUsers();
45. return "list";
46. }
47. /*
48. * 在测试load方法的时候因为是getCurrentSession load 完了就关闭
49. * 在web.xml里面配置 OpenSessionInViewFilter jsp关闭session才关闭不过要配置的
50. * StrutsPrepareAndExecuteFilter的前面
51. */
52.
53.
54.
55. public String load() {
56. this.user = this.userManager.loadById(info.getId());
57. return "load";
58. }
59.
60. @Override
61. public String execute() throws Exception {
62.
63. //判断乱码问题
64.
65.
66. new User();
67. user.setUsername(info.getUsername());
68. user.setPassword(info.getPassword());
69. if(userManager.exists(user)) {
70. return "fail";
71. }
72. userManager.add(user);
73. return "success";
74. }
75.
76. public UserRegisterInfo getInfo() {
77. return info;
78. }
79. public void setInfo(UserRegisterInfo info) {
80. this.info = info;
81. }
82.
83. @Override
84. public Object getModel() {
85. return info;
86. }
87.
88. public List<User> getUsers() {
89. return users;
90. }
91.
92. public void setUsers(List<User> users) {
93. this.users = users;
94. }
95.
96. public User getUser() {
97. return user;
98. }
99.
100. public void setUser(User user) {
101. this.user = user;
102. }
103. }
1. <?xml version="1.0" encoding="UTF-8" ?>
2. <!DOCTYPE struts PUBLIC
3. "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
4. >
5.
6. <struts>
7. <constant name="struts.devMode" value="true"/>
8.
9. <package name="registration" extends="struts-default">
10. <action name="userAction" class="u">
11. <result name="success">/registerSuccess.jsp</result>
12. <result name="fail">/registerFail.jsp</result>
13. <result name="list">/userlist.jsp</result>
14. <result name="load">/user.jsp</result>
15. </action>
16. </package>
17.
18.
19. </struts>本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
