ssh運行環境搭建及測試

本文轉載自查看原文 2018-05-08 13:25 2158 SSH項目_CRM

一、運行環境

　　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

 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>

　　5、開測

　　輸入網址：http://localhost:8080/TFCRM/UserAction_login

　　登陸：成功跳轉到index.html

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 Maven搭建SSH環境 Cordova4.0 環境搭建-測試運行搭建python運行環境 java運行環境搭建 PHP運行環境搭建 SSH開發環境搭建 Hadoop——運行環境搭建性能測試環境搭建 Mybatis環境搭建及測試測試環境搭建