ssh运行环境搭建及测试

一、运行环境

　　1、Spring环境

　　Spring是一站式开发框架，在SSH中主要有以下作用，就像一个大管家：

  • 控制反转（Inversion of Control）：类不再自己进行类创建，而是交给Spring框架来管理（包括创建、依赖注入、生命周期等）。即Spring是一个工厂，类都交由该框架进行创建，而只需要将信息配置到主配置文件中，Spring就能自动管理类，比如Struts2的Action类、Hibernate的sessionFactory类。程序员只需重点关注业务逻辑即可。
  • 依赖注入（Dependency Injection）：其实也是控制反转的一部分。即自动注入依赖对象或属性，无需手动创建。
  • AOP编程：面向切面的编程。比如AOP的事务管理，将事务交由Spring管理，会话对象session等也交由Spring管理，而程序员只需专注数据库业务即可。

　　Spring的环境配置可以参考W3C官网的说明：https://www.w3cschool.cn/wkspring/f6pk1ic8.html

　　导包

  • 4个核心组件包
  • 2个日志包
  • 整合web的包：
  • 整合aop的包（4）
  • 整合hibernate和事务的包（4）
  • Junit4测试包

　　编写配置文件，并导入4个约束（beans、context、aop、tx）

  • applicationContext.xml（放在src下）
     
    <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns="http://www.springframework.org/schema/beans" 
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:aop="http://www.springframework.org/schema/aop" 
        xmlns:tx="http://www.springframework.org/schema/tx"
        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd 
                            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd 
                            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd 
                            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd ">
        
        
</beans>
  • web.xml：配置Spring随项目启动而启动
     
    <?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
  <display-name>TFCRM</display-name>
  
  <!-- 配置Spring随web项目启动而启动 -->
  <listener>
      <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <context-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:applicationContext.xml</param-value>
  </context-param>
  
  <welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>default.html</welcome-file>
    <welcome-file>default.htm</welcome-file>
    <welcome-file>default.jsp</welcome-file>
  </welcome-file-list>
</web-app>
    View Code

　　测试：我们搭好环境后需要进行测试（好的习惯！）

　　随便写一个html欢迎页面：

  • <!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
    <h1>Hello Spring！</h1>
</body>
</html>

　　　

　　2、Struts2环境

　　Struts2的前身是webwork。是基于MVC设计模式的web应用程序架构，以简化web层开发人员的编程工作。

　　导包

  • struts-blank.war/WEB-INF/lib/*（可能会与其他包重复）
  • Struts2整合Spring插件包（注意：一旦导入，Struts2会在启动时寻找Spring容器，找不到会报错）

　　编写配置文件

  • 主配置文件：struts.xml（可以暂时不填如内容）
    <?xml version="1.0" encoding="UTF-8"?>
  <!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
    "http://struts.apache.org/dtds/struts-2.3.dtd">
    
<struts>
    
</struts>
  • 将核心过struts2的核心过滤器配置到web.xml中
      <!-- 配置Struts2的核心过滤器 -->
  <filter>
      <filter-name>struts2</filter-name>
      <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
  </filter>
  <filter-mapping>
      <filter-name>struts2</filter-name>
      <url-pattern>/*</url-pattern>
  </filter-mapping>

　　配置完后启动一下服务器观察是否报错。

　　3、Hibernate环境

　　Hibernate框架使用ORM思想，即Object Relation Mapping，对象关系映射。通过orm技术实现面向对象地操作数据库，从而实现自动生成sql语句、动态管理数据库等。（但我认为面向对操作数据库象这一思想是没错的，只是开发者如果不能直接对sql进行操作就很难做到优化数据库，所以hibernate框架也提供的原生的sql语句以供使用）。

　　导包

  • hibernate/lib/required目录下的包（9）
  • hibernate/lib/jpa | java persist api java的持久化规范(接口)
  • 数据库驱动包（我使用的是mysql）

　　编写实体类和orm元数据（这里我随便写个User类测试一下）

package com.fzz.domain;

public class User {
    /*
     * 数据库表user
     * CREATE TABLE `user` (
      `user_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '用户id',
      `user_code` varchar(32) NOT NULL COMMENT '用户账号',
      `user_name` varchar(64) NOT NULL COMMENT '用户名称',
      `user_password` varchar(32) NOT NULL COMMENT '用户密码',
      PRIMARY KEY (`user_id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=9 DEFAULT CHARSET=utf8;
     */
    private Long user_id;
    private String user_code;
    private String user_name;
    private String user_password;
    public Long getUser_id() {
        return user_id;
    }
    public void setUser_id(Long user_id) {
        this.user_id = user_id;
    }
    public String getUser_code() {
        return user_code;
    }
    public void setUser_code(String user_code) {
        this.user_code = user_code;
    }
    public String getUser_name() {
        return user_name;
    }
    public void setUser_name(String user_name) {
        this.user_name = user_name;
    }
    public String getUser_password() {
        return user_password;
    }
    public void setUser_password(String user_password) {
        this.user_password = user_password;
    }

    @Override
    public String toString() {
        return "User [user_id=" + user_id + ", user_code=" + user_code + ", user_name=" + user_name + ", user_password="
                + user_password + "]";
    }
}
User
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
    
<hibernate-mapping package="com.fzz.domain" >
    <class name="User" table="user" >
        <id name="user_id"  >
            <generator class="native"></generator>
        </id>
        <property name="user_code"  ></property>
        <property name="user_name"  ></property>
        <property name="user_password"  ></property>
    
    </class>
</hibernate-mapping>
User.hbm.xml

　　编写配置文件：hibernate.cfg.xml

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE hibernate-configuration PUBLIC
 3     "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
 4     "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
 5 <hibernate-configuration>
 6     <session-factory>
 7         <!-- 【基本配置】 -->
 8          <!-- 数据库驱动 -->
 9         <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
10          <!-- 数据库url -->
11         <property name="hibernate.connection.url">jdbc:mysql:///tf_crm</property>
12          <!-- 数据库连接用户名 -->
13         <property name="hibernate.connection.username">root</property>
14          <!-- 数据库连接密码 -->
15         <property name="hibernate.connection.password">123456</property>
16         <!-- 数据库方言
17             注意: MYSQL在选择方言时,请选择最短的方言.
18          -->
19         <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
20         
21         <!--【可选配置】-->
22         <!-- 将hibernate生成的sql语句打印到控制台 -->
23         <property name="hibernate.show_sql">true</property>
24         <!-- 将hibernate生成的sql语句格式化(语法缩进) -->
25         <property name="hibernate.format_sql">true</property>
26         <!-- 自动导出表结构. 自动建表-->
27         <property name="hibernate.hbm2ddl.auto">update</property>
28          
29          <!-- 引入实体配置文件 -->
30         <mapping resource="com/fzz/domain/User.hbm.xml" />
31         
32     </session-factory>
33 </hibernate-configuration>

　　测试

 1 package com.fzz.test;
 2 
 3 import org.hibernate.Session;
 4 import org.hibernate.SessionFactory;
 5 import org.hibernate.Transaction;
 6 import org.hibernate.cfg.Configuration;
 7 import org.junit.Test;
 8 import org.junit.runner.RunWith;
 9 import org.springframework.test.context.ContextConfiguration;
10 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
11 
12 import com.fzz.domain.User;
13 
14 /**
15  * @author Fzz
16  * @date 2018年5月7日
17  * @Description TODO:测试Hibernate
18  */
19 @RunWith(SpringJUnit4ClassRunner.class)
20 @ContextConfiguration("classpath:applicationContext.xml")
21 public class HibernateTest {
22         @Test
23         public void addUser(){
24             //加载配置文件
25             Configuration conf = new Configuration().configure();
26             //创建SessionFactory类
27             SessionFactory sf = conf.buildSessionFactory();
28             //获得连接对象session
29             Session session = sf.openSession();
30             //开启事务
31             Transaction tx = session.beginTransaction();
32             //-------------------------------------------------
33             //【操作User对象】
34             User u = new User();
35             u.setUser_code("rose");
36             u.setUser_name("肉丝");
37             u.setUser_password("1234");
38             
39             //持久化User对象
40             session.save(u);
41             
42             //-------------------------------------------------
43             tx.commit();
44             session.close();
45             sf.close();
46         }
47 
48 }
View Code

　　注：在测试之前我们需要先在mysql中创建配置文件中指定的数据库，如果没有会发生异常。

　　执行结果：（我们发现hibernate为我们自动建表并成功插入数据）

　　

　　4、ssh环境（环境包整包下载）

　　除了上面所需要的包，如果需要实现其他功能可能还需要导包，根据需求增加即可。另外除了框架包，我们还需要标签库包，用于编写jsp等时导入：

　　

　　为方便导包，下面是项目整包（可能版本更新包名会变化），提供下载：

　　云盘：https://pan.baidu.com/s/1qW22-JDqDGGSyZuebIhFFg。密码：9kue

二、使用Spring进行整合（管理）

　　1、Spring整合Struts2

　　即将Action类交于Spring管理。一般有两种整合方案（推荐方案二）。

　　在struts.xml中常量配置

  •   <!-- 配置Struts2的核心过滤器 -->
  <filter>
      <filter-name>struts2</filter-name>
      <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
  </filter>
  <filter-mapping>
      <filter-name>struts2</filter-name>
      <url-pattern>/*</url-pattern>
  </filter-mapping>

　　为了方便说明以及测试，我们先创建Action类和Service实现类。

 1 package com.fzz.web.action;
 2 
 3 import com.fzz.service.UserService;
 4 import com.opensymphony.xwork2.ActionSupport;
 5 
 6 public class UserAction extends ActionSupport {
 7     private static final long serialVersionUID = 7278361961522411202L;
 8     
 9     private UserService userService;
10     
11     //用户登录
12     public String login() throws Exception {
13         System.out.println(userService);//打印观察userService是否自动装配了
14         return super.execute();
15     }
16     
17     public void setUserService(UserService userService) {
18         this.userService = userService;
19     }
20     
21 }
UserAction
 1 package com.fzz.service;
 2 
 3 import com.fzz.domain.User;
 4 
 5 public interface UserService {
 6 
 7     //通过账号密码获得User对象
 8     User getUserByCodePassword(User u);
 9     
10 }
UserService
 1 package com.fzz.service.impl;
 2 
 3 import com.fzz.domain.User;
 4 import com.fzz.service.UserService;
 5 
 6 public class UserServiceImpl implements UserService {
 7 
 8     @Override
 9     public User getUserByCodePassword(User u) {
10         System.out.println("getUserByCode()...");
11         return null;
12     }
13 
14 }
UserServiceImpl

 　　并交由Spring管理：

　　

　　整合方案一：Action仍由Struts创建，Spring负责装配依赖属性（不推荐）

　　

　　测试：启动项目→打开浏览器输入：http://localhost:8080/TFCRM/UserAction_login。（结果打印了，说明自动装配了service实现类）

　　

　　整合方案二：Action交由Spring来创建，并注入依赖属性（推荐）

　　

　　

　　同样的方法测试一下：

　　

　　2、Spring整合Hibernate

　　使用Spring整合hibernate，主要是管理sessionFactory类。同样有两种方案（推荐第二种）：

　　整合方案一：

　　

　　整合方案二：

  •  1 <bean name="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
 2     <!-- 配置hibernate基本信息 -->
 3     <property name="hibernateProperties">
 4         <props>
 5             <!-- 必选配置 -->
 6             <prop key="hibernate.connection.driver_class">com.mysql.jdbc.Driver</prop>
 7             <prop key="hibernate.connection.url">jdbc:mysql:///tf_crm</prop>
 8             <prop key="hibernate.connection.username">root</prop>
 9             <prop key="hibernate.connection.password">123456</prop>
10             <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
11             <!-- 可选配置 -->
12             <prop key="hibernate.show_sql" >true</prop>
13             <prop key="hibernate.format_sql" >true</prop>
14             <prop key="hibernate.hbm2ddl.auto" >update</prop>
15         </props>
16     </property>
17     <!-- 引入orm元数据（指定orm元数据所在包即可自动扫描并引入） -->
18     <property name="mappingDirectoryLocations" value="classpath:com.fzz.domain"></property>
19 </bean>

　　注：这样hibernate.config.xml就用不到了，可以删除了。

　　别忘了测试一下：

 1 package com.fzz.test;
 2 
 3 import javax.annotation.Resource;
 4 
 5 import org.hibernate.Session;
 6 import org.hibernate.SessionFactory;
 7 import org.hibernate.Transaction;
 8 import org.junit.Test;
 9 import org.junit.runner.RunWith;
10 import org.springframework.test.context.ContextConfiguration;
11 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
12 import com.fzz.domain.User;
13 
14 @RunWith(SpringJUnit4ClassRunner.class)
15 @ContextConfiguration("classpath:applicationContext.xml")
16 public class SpringPluginHibernateTest{
17     
18     @Resource(name="sessionFactory")
19     private SessionFactory sf ;//使用Spring注入（有三种注入方式，这里使用注解注入，所以不需要setter方法）
20     
21     @Test
22     public void addUser(){
23         Session session = sf.openSession();
24         Transaction tx = session.beginTransaction();
25         //-------------------------------------------------
26         User u = new User();
27         u.setUser_code("jack");
28         u.setUser_name("杰克");
29         u.setUser_password("123456");
30         session.save(u);
31         //-------------------------------------------------
32         tx.commit();
33         session.close();
34     }
35 }
pringPluginHibernateTest

　　

　　3、Spring整合C3P0

　　即使用Spring管理C3P0，首先将C3P0注入到主配置文件中：

  • 编写db.properties
    jdbc.jdbcUrl=jdbc:mysql:///TFCRM
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.user=root
jdbc.password=123456
  • 编写applicationContext.xml
    <!-- 【c3p0】 -->
<!-- 读取db.properties文件 -->
<context:property-placeholder location="classpath:db.properties" />
<!-- 配置c3p0连接池 -->
<bean name="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" >
    <property name="jdbcUrl" value="${jdbc.jdbcUrl}" ></property>
    <property name="driverClass" value="${jdbc.driverClass}" ></property>
    <property name="user" value="${jdbc.user}" ></property>
    <property name="password" value="${jdbc.password}" ></property>
</bean>
  • 将连接池注入给SessionFactory
    <property name="dataSource" ref="dataSource"></property>
  • 由于c3p0已经配置了数据库连接的必选信息，所以将之前的必选信息删除，只留下数据库方言即可
    <!-- 必选配置 -->
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>

　　3、使用Spring提供的HibernateTemplate进行数据库操作

　　HibernateTemplate是一个hibernate的工具类。现在我们在dao层使用一下（需要继承HibernateDaoSupport类，该类可提供hibernateTemplate的实例）

1 package com.fzz.dao;
2 
3 import com.fzz.domain.User;
4 
5 public interface UserDao {
6     User getUserByCode(String code);//根据用户账号查询用户
7 }
UserDao
 1 package com.fzz.dao.impl;
 2 
 3 import java.util.List;
 4 
 5 import org.hibernate.HibernateException;
 6 import org.hibernate.Query;
 7 import org.hibernate.Session;
 8 import org.hibernate.criterion.DetachedCriteria;
 9 import org.hibernate.criterion.Restrictions;
10 import org.springframework.orm.hibernate5.HibernateCallback;
11 import org.springframework.orm.hibernate5.HibernateTemplate;
12 import org.springframework.orm.hibernate5.support.HibernateDaoSupport;
13 
14 import com.fzz.dao.UserDao;
15 import com.fzz.domain.User;
16 
17 public class UserDaoImpl extends HibernateDaoSupport implements UserDao {
18     
19     HibernateTemplate ht;//继承HibernateDaoSupport，是因为HibernateDaoSupport能提供HibernateTemplate。
20     
21     @Override
22     public User getUserByCode(final String usercode) {
23         //【使用原生sql操作】
24         /*        return this.getHibernateTemplate().execute(new HibernateCallback<User>() {
25             public User doInHibernate(Session session) throws HibernateException {
26                 //----------------------------
27                 String sql = "select * from user where user_code=?";
28                 Query query = session.createQuery(sql);
29                 query.setParameter(0, usercode);//上面使用了final，所以可以使用
30                 User user = (User)query.uniqueResult();
31                 return user;
32                 //-----------------------------
33             }
34         });*/
35         //【使用criteria操作】
36         DetachedCriteria dc = DetachedCriteria.forClass(User.class);//获得离线查询对象
37         dc.add(Restrictions.eq("user_code", usercode));//添加离线查询条件
38         
39         List<User> list = (List<User>) getHibernateTemplate().findByCriteria(dc);//获得查询结果集
40         
41         if(list!=null&&list.size()>0)
42             return list.get(0);//我们打印一条记录查看效果即可
43         else
44             return null;
45     }
46 
47 }
UserDaoImpl

　　然后我们需要使用Spring来管理Dao，所以别忘了在配置文件中配置dao的<bean>：

  • <bean name="userDao" class="com.fzz.dao.impl.UserDaoImpl">
    <property name="sessionFactory" ref="sessionFactory"></property>
</bean>

　　测试一下：

 1 package com.fzz.test;
 2 
 3 import javax.annotation.Resource;
 4 
 5 import org.junit.Test;
 6 import org.junit.runner.RunWith;
 7 import org.springframework.test.context.ContextConfiguration;
 8 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 9 
10 import com.fzz.dao.UserDao;
11 import com.fzz.domain.User;
12 
13 @RunWith(SpringJUnit4ClassRunner.class)
14 @ContextConfiguration("classpath:applicationContext.xml")
15 public class hibernateTemplateTest {
16     @Resource(name="userDao")
17     UserDao ud;
18     @Test
19     public void fun(){
20         User u = ud.getUserByCode("rose");
21         System.out.print(u.toString());
22     }
23 }
hibernateTemplateTest

　　测试结果：

　　

　　4、Spring的AOP事务管理

　　将事务交给Spring，那么你就不用再考虑事务的打开关闭异常处理等问题，简直不要太爽。（咳咳）

　　一般可以采用两种配置（各有优缺点，建议使用.xml配置）：

  • 准备工作：配置核心事务管理器到applicationContext.xml中
    <!-- 【核心事务管理器】 -->
<bean name="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
    <property name="sessionFactory" ref="sessionFactory"></property>
</bean>
  • 在xml文件中配置事务通知、aop织入。
    <!-- 配置事务通知 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <tx:method name="save*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
        <tx:method name="persist*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
        <tx:method name="update*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
        <tx:method name="modify*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
        <tx:method name="delete*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
        <tx:method name="remove*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
        <tx:method name="get*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="true" />
        <tx:method name="find*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="true" />
        <tx:method name="*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
        </tx:attributes>
</tx:advice>
<!-- 配置aop：将通知织入目标对象 -->
 <aop:config>
     <!-- 切点 -->
    <aop:pointcut expression="execution(* com.fzz.service.impl.*ServiceImpl.*(..))" id="txPc"/>
    <!-- 切面 -->
    <aop:advisor advice-ref="txAdvice" pointcut-ref="txPc" />
</aop:config>
    View Code
  • 使用注解配置通知
    首先要在配置文件中开启注解事务的功能
     
    <tx:annotation-driven transaction-manager="transactionManager" />
    然后在service类中使用注解即可。

　　我们来测试一下：首先在UserSercive接口中书写一个方法saveUser()来保存对象，然后调用UserDao进行保存，过程很简单，这里就不贴代码了。

　　注：由于我们在UserServiceImpl中使用了dao，需要Spring进行依赖注入，所以别忘了配置<property>。

　　直接看测试类：

 1 package com.fzz.test;
 2 
 3 import javax.annotation.Resource;
 4 
 5 import org.junit.Test;
 6 import org.junit.runner.RunWith;
 7 import org.springframework.test.context.ContextConfiguration;
 8 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 9 
10 import com.fzz.domain.User;
11 import com.fzz.service.UserService;
12 
13 @RunWith(SpringJUnit4ClassRunner.class)
14 @ContextConfiguration("classpath:applicationContext.xml")
15 public class aopTxTest {
16     @Resource(name="userService")
17     private UserService  us;
18     
19     @Test
20     public void fun(){
21         User user = new User();
22         user.setUser_code("Leslie");
23         user.setUser_name("何宝荣");
24         us.saveUser(user);
25     }
26 }
aopTxTest

　　看一下保存结果：

　　

　　5、扩大Hibernate中session的作用范围

　　为了避免懒加载时出现no-session问题，我们需要扩大session的作用范围。我们需要使用一个过滤器OpenSessionInViewFilter来实现：

　　在web.xml中配置过滤器，主要注意的是过滤器的加载是有顺序的，所以这里我们要将该过滤器配置到struts核心过滤器之前：

  •  1 <?xml version="1.0" encoding="UTF-8"?>
 2 <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
 3   <display-name>TFCRM</display-name>
 4   
 5   <!-- 配置Spring随web项目启动而启动 -->
 6   <listener>
 7       <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
 8   </listener>
 9   <context-param>
10       <param-name>contextConfigLocation</param-name>
11       <param-value>classpath:applicationContext.xml</param-value>
12   </context-param>
13   
14   <!-- 扩大session作用范围的过滤器 -->
15     <filter>
16       <filter-name>openSessionInView</filter-name>
17       <filter-class>org.springframework.orm.hibernate5.support.OpenSessionInViewFilter</filter-class>
18   </filter>
19   <!-- 配置Struts2的核心过滤器 -->
20   <filter>
21       <filter-name>struts2</filter-name>
22       <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
23   </filter>
24 
25   <filter-mapping>
26       <filter-name>openSessionInView</filter-name>
27       <url-pattern>/*</url-pattern>
28   </filter-mapping>  
29   <filter-mapping>
30       <filter-name>struts2</filter-name>
31       <url-pattern>/*</url-pattern>
32   </filter-mapping>
33   
34   <welcome-file-list>
35     <welcome-file>index.html</welcome-file>
36     <welcome-file>index.htm</welcome-file>
37     <welcome-file>index.jsp</welcome-file>
38     <welcome-file>default.html</welcome-file>
39     <welcome-file>default.htm</welcome-file>
40     <welcome-file>default.jsp</welcome-file>
41   </welcome-file-list>
42 </web-app>
    View Code

三、练习：使用ssh进行用户登录

　　环境搭建完毕，我们需要实现一个具体的业务来检测一下。比如常见的用户登录功能。

　　JavaWeb开发一般分为三层即：web层、service层、dao层。所以我们登录业务也需要分层完成。

　　1、web层

　　首先提一下：struts2接受表单有三种方式（各有优缺点）：

  • get/set（）方法接收
    这种方法需要在action类下提供属性，且提供get/set()方法，字段名要求与页面表单的属性name一致，然后struts2就能自动接收赋值。
  • 使用JavaBean封装参数
    这种方法是要求将传入的参数都包含在一个自定义JavaBean中，在action中以JavaBean对象为属性并提供get/set()方法，且要求页面表单的name属性值写成"name=bean.XXX"的形式，bean是自定义JavaBean的实例引用名称。
  • 使用ModelDriven模式进行参数封装

    使用ModelDriven方式，首先要实现ModelDriven接口和getModel方法。

　　这里不再赘述，了解细节可自行百度。这里我们采用ModelDriven模式进行参数封装。

  •  1 package com.fzz.web.action;
 2 
 3 import com.fzz.domain.User;
 4 import com.fzz.service.UserService;
 5 import com.opensymphony.xwork2.ActionContext;
 6 import com.opensymphony.xwork2.ActionSupport;
 7 import com.opensymphony.xwork2.ModelDriven;
 8 
 9 public class UserAction extends ActionSupport implements ModelDriven<User>{
10     private static final long serialVersionUID = 7278361961522411202L;
11     
12     private UserService userService;
13     private User user = new User();//用于接收表单参数
14     
15     //用户登录
16     public String login() throws Exception {
17         //1 调用Service执行登陆逻辑
18         User u = userService.getUserByCodePassword(user);
19         //2 将返回的User对象放入session域
20         ActionContext.getContext().getSession().put("user", u);
21         //3 重定向到首页
22         return "toHome";
23     }
24     
25     public void setUserService(UserService userService) {
26         this.userService = userService;
27     }
28 
29     @Override
30     public User getModel() {
31         return user;
32     }
33     
34 }
    UserAction

　　下面还需要修改配置文件中的action下的result：

  • <action name="UserAction_*" class="userAction" method="{1}">
    <result name="toHome">/index.html</result>
</action>

　　2、service层

  •  1 public User getUserByCodePassword(User u) {
 2         //1 根据登陆名称查询登陆用户
 3         User existU = ud.getByUserCode(u.getUser_code());
 4         //2 判断用户是否存在.不存在=>抛出异常,提示用户名不存在
 5         if(existU==null){
 6             throw new RuntimeException("用户名不存在!");
 7         }
 8         //3 判断用户密码是否正确=>不正确=>抛出异常,提示密码错误
 9         if(!existU.getUser_password().equals(u.getUser_password())){
10             throw new RuntimeException("密码错误!");
11         }
12         //4 返回查询到的用户对象
13     
14     return existU;
15 }

     这里的登录逻辑很简单就不再细述，值得注意的是如果过户名或密码错误，即抛出异常，我们希望用户能看到异常信息，那么我们就需要进行异常处理，即通过配置文件来配置异常结果处理：

　　

　　3、dao层

　　之前测试的时候已经实现了，这里就不用再编写代码了。

　　4、显示页面

　　显示页面包括两个，一个登陆页面login.jsp，一个主页index.html。

　　比如index,html：

  •  1 <!DOCTYPE html>
 2 <html>
 3 <head>
 4 <meta charset="UTF-8">
 5 <title>Insert title here</title>
 6 </head>
 7 <body>
 8     <a href="https://www.cnblogs.com/fzz9/" style="text-decoration: none;">
 9         <h2>&nbsp;&nbsp;&nbsp;&nbsp;《你见或者不见我》</h2>
10     </a>
11     <pre>
12      作者：扎西拉姆多多
13     你见，或者不见我
14     我就在那里
15     不悲 不喜
16     你念，或者不念我
17     情就在那里
18     不来 不去
19     你爱，或者不爱我
20     爱就在那里
21     不增 不减
22     你跟，或者不跟我
23     我的手就在你手里
24     不舍不弃
25     来我的怀里
26     或者
27     让我住进你的心里
28     默然 相爱
29     寂静 欢喜
30     </pre>
31 </body>
32 </html>
    index.html

    login.jsp文件由于有图且导入了一些css文件，这里直接拷贝访问界面会很混乱，可以自己写一个，下面只是提供参考

  •  1 <%@ page language="java" contentType="text/html; charset=UTF-8"
 2     pageEncoding="UTF-8"%>
 3     <%@ taglib prefix="s" uri="/struts-tags" %>
 4 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3c.org/TR/1999/REC-html401-19991224/frameset.dtd">
 5 <HTML xmlns="http://www.w3.org/1999/xhtml">
 6 <HEAD>
 7 <META http-equiv=Content-Type content="text/html; charset=utf-8">
 8 <STYLE type=text/css>
 9 BODY {
10     FONT-SIZE: 12px; COLOR: #ffffff; FONT-FAMILY: 宋体
11 }
12 TD {
13     FONT-SIZE: 12px; COLOR: #ffffff; FONT-FAMILY: 宋体
14 }
15 </STYLE>
16 
17 <META content="MSHTML 6.00.6000.16809" name=GENERATOR>
18 <script type="text/javascript">
19     window.onload=function(){
20         if(window.parent != window){// 如果是在框架中
21             //就让框架页面跳转到登陆页面
22             window.parent.location.href = "${pageContext.request.contextPath}/login.jsp";
23         }
24     };
25 </script>
26 
27 </HEAD>
28 <BODY>
29 <FORM id=form1 name=form1 action="${pageContext.request.contextPath}/UserAction_login"  method=post>
30 
31 <DIV id=UpdatePanel1>
32 <DIV id=div1 
33 style="LEFT: 0px; POSITION: absolute; TOP: 0px; BACKGROUND-COLOR: #0066ff"></DIV>
34 <DIV id=div2 
35 style="LEFT: 0px; POSITION: absolute; TOP: 0px; BACKGROUND-COLOR: #0066ff"></DIV>
36 
37 
38 <DIV>&nbsp;&nbsp; </DIV>
39 <DIV>
40 <TABLE cellSpacing=0 cellPadding=0 width=900 align=center border=0>
41   <TBODY>
42   <TR>
43     <TD style="HEIGHT: 105px"><IMG src="images/login_1.gif" 
44   border=0></TD></TR>
45   <TR>
46     <TD background=images/login_2.jpg height=300>
47       <TABLE height=300 cellPadding=0 width=900 border=0>
48         <TBODY>
49         <TR>
50           <TD colSpan=2 height=35></TD></TR>
51         <TR>
52           <TD width=360></TD>
53           <TD>
54             <TABLE cellSpacing=0 cellPadding=2 border=0>
55               <TBODY>
56               <TR>
57                 <TD style="HEIGHT: 28px" width=80>登 录 名：</TD>
58                 <TD style="HEIGHT: 28px" width=150><INPUT id=txtName 
59                   style="WIDTH: 130px" name="user_code"></TD>
60                 <TD style="HEIGHT: 28px" width=370><SPAN 
61                   id=RequiredFieldValidator3 
62                   style="FONT-WEIGHT: bold; VISIBILITY: hidden; COLOR: white">请输入登录名</SPAN></TD></TR>
63               <TR>
64                 <TD style="HEIGHT: 28px">登录密码：</TD>
65                 <TD style="HEIGHT: 28px"><INPUT id=txtPwd style="WIDTH: 130px" 
66                   type=password name="user_password"></TD>
67                 <TD style="HEIGHT: 28px"><SPAN id=RequiredFieldValidator4 
68                   style="FONT-WEIGHT: bold; VISIBILITY: hidden; COLOR: white">请输入密码</SPAN></TD></TR>
69               <TR>
70                 <TD style="HEIGHT: 28px">验证码：</TD>
71                 <TD style="HEIGHT: 28px"><INPUT id=txtcode 
72                   style="WIDTH: 130px" name=txtcode></TD>
73                 <TD style="HEIGHT: 28px">&nbsp;</TD></TR>
74               <TR>
75                 <TD style="HEIGHT: 18px" colspan="2" ><font color="red" ><s:property value="exception.message" /> </font></TD>
76                 <TD style="HEIGHT: 18px"></TD></TR>
77               <TR>
78                 <TD colspan="2"><INPUT id=btn 
79                   style="BORDER-TOP-WIDTH: 0px; BORDER-LEFT-WIDTH: 0px; BORDER-BOTTOM-WIDTH: 0px; BORDER-RIGHT-WIDTH: 0px" 
80                   type=image src="images/login_button.gif" name=btn>
81                   <img src="images/regist_button.png" style="cursor: pointer;" onclick="window.location.href='${pageContext.request.contextPath}/register.jsp'" >
82               </TD></TR></TBODY></TABLE></TD></TR></TBODY></TABLE></TD></TR>
83   <TR>
84     <TD><IMG src="images/login_3.jpg" 
85 border=0></TD></TR></TBODY></TABLE></DIV></DIV>
86 
87 
88 </FORM>
89 <s:debug></s:debug>
90 </BODY></HTML>
    login.jsp

　　5、开测

　　输入网址：http://localhost:8080/TFCRM/UserAction_login

　　

　　登陆：成功跳转到index.html

　　

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/fzz9/p/9002166.html