SSH2框架整合--实现登录

发表于 | 更新于 | 分类于 | 评论数： | 阅读次数：

知识点回顾

知识点总结

开始整合（使用Maven）

使用Maven新建一个项目:（关于Eclipse中使用Maven可参看这篇文章）

新建好一个空的Maven项目结构是这样的

空的项目图

接下来你需要在pom.xml中配置项目需要的jar包，eclipse会为你下载，以后开发时，你可以(到Maven的官网查找需要的包进行下载)

pom.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com</groupId>
  <artifactId>SSH2LoginDemo</artifactId>
  <packaging>war</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>SSH2LoginDemo Maven Webapp</name>
  <url>http://maven.apache.org</url>
  <dependencies>
        <!-- 导入junit -->
       <dependency>
           <groupId>junit</groupId>
           <artifactId>junit</artifactId>
           <version>4.12</version>
           <scope>test</scope>
       </dependency>
       <!-- 导入基本的javax.servlet -->
       <!-- https://mvnrepository.com/artifact/javax.servlet/servlet-api -->
       <dependency>
           <groupId>javax.servlet</groupId>
           <artifactId>servlet-api</artifactId>
           <version>2.5</version>
       </dependency>
       <!-- 导入Mysql的连接驱动包 -->
       <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
       <dependency>
           <groupId>mysql</groupId>
           <artifactId>mysql-connector-java</artifactId>
           <version>6.0.5</version>
       </dependency>
       <!-- https://mvnrepository.com/artifact/org.apache.struts/struts2-spring-plugin -->
       <dependency>
           <groupId>org.apache.struts</groupId>
           <artifactId>struts2-spring-plugin</artifactId>
           <version>2.5</version>
       </dependency>
       <!-- http://projects.spring.io/spring-framework/ -->
       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-context</artifactId>
           <version>4.3.5.RELEASE</version>
       </dependency>
       <!-- http://projects.spring.io/spring-framework/ -->
       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-core</artifactId>
           <version>4.3.5.RELEASE</version>
       </dependency>
       <!-- https://mvnrepository.com/artifact/org.springframework/spring-orm -->
       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-orm</artifactId>
           <version>4.3.5.RELEASE</version>
       </dependency>
       <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-beans</artifactId>
           <version>4.3.5.RELEASE</version>
       </dependency>
       <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
       <dependency>
           <groupId>org.aspectj</groupId>
           <artifactId>aspectjweaver</artifactId>
           <version>1.8.10</version>
       </dependency>
       <!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-core -->
       <dependency>
           <groupId>org.hibernate</groupId>
           <artifactId>hibernate-core</artifactId>
           <version>5.2.9.Final</version>
       </dependency>
       <!-- https://mvnrepository.com/artifact/org.javassist/javassist -->
       <dependency>
           <groupId>org.javassist</groupId>
           <artifactId>javassist</artifactId>
           <version>3.22.0-CR1</version>
       </dependency>
       <!-- druid连接池 -->
       <!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
       <dependency>
           <groupId>com.alibaba</groupId>
           <artifactId>druid</artifactId>
           <version>1.0.26</version>
       </dependency>
       <!-- j2ee的注解 -->
       <!-- https://mvnrepository.com/artifact/javax.annotation/javax.annotation-api -->
            <dependency>
            <groupId>javax.annotation</groupId>
            <artifactId>javax.annotation-api</artifactId>
            <version>1.2</version>
        </dependency>
  </dependencies>
  <build>
    <finalName>SSH2LoginDemo</finalName>
  </build>
</project>

新建四个文件放在src/main/resource中

-  applicationContext.xml（配置spring）
-   jdbc.properties（数据库连接的属性文件）
-  log4j.properties（日志记录属性文件）
-  struts.xml（struts2的配置文件）

先写上日志记录需要的属性文件，其他三个文件具体内容在编码时给出
log4j.properties

1
2
3
4
5
6
7
8
9
10
11
12
### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
### direct messages to file mylog.log ###
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=D:\mylog.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
### set log levels - for more verbose logging change 'info' to 'debug' ###
log4j.rootLogger=warn, stdout

之后你需要在src/main/webapp/WEB-INF/web.xml中添加Spring的核心监听器和Struts2的过滤器

web.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
<?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"
    version="2.5">
  <display-name>SSH2LoginDemo</display-name>
    <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>
    <!-- needed for ContextLoaderListener -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>

    <!-- Bootstraps the root web application context before servlet initialization -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <!-- 配置struts2拦截器-核心过滤器 -->
    <filter>
        <filter-name>struts2</filter-name>
        <filter-class>org.apache.struts2.dispatcher.filter.StrutsPrepareAndExecuteFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>struts2</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    
</web-app>

具体编码前，我们先创建包和文件结构，结构图如下：

MVC结构图

开始编码：

一. 视图层(登录：login.jsp ，登录成功：loginSuccess.jsp ，登录失败：回到login.jsp)

login.jsp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@taglib prefix="s" uri="/struts-tags" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>登录</title>
</head>
<body>
    <!-- 如果登录失败，显示登录失败信息 -->
    <h1><s:property value="fieldErrors.loginFail"/></h1>
    <form action="user_login" method="post">
        用户名：<input type="text" name="username">
        密码：<input type="password" name="password">
        <input type="submit" value="登录">
    </form>
</body>
</html>

loginSuccess.jsp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>登录成功</title>
</head>
<body>
    <!-- 欢迎消息，显示登陆用户的用户名 -->
    <h1>欢迎你:<s:property value="username"/></h1>
    <s:debug></s:debug>
</body>
</html>

二.控制层(UserAction)，通过Struts.xml配置请求的Action

Struts.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.5//EN"
    "http://struts.apache.org/dtds/struts-2.5.dtd">
<struts>
    <!-- 开发模式 -->
    <constant name="struts.devMode" value="true"></constant>
    <!-- action的配置 -->
    <package name="ssh" namespace="/" extends="struts-default">
        <!-- 为了安全起见，Struts2对Action中可执行的方法进行了声明，此处声明为全部 -->
        <global-allowed-methods>regex:.*</global-allowed-methods>
        <!-- 匹配方法，Action交给了Spring管理，所以class属性这样写 -->
        <action name="user_*" class="userAction" method="{1}">
            <!-- 成功跳转到登录成功页面 -->
            <result name="success">/loginSuccess.jsp</result>
            <!-- 失败回到登录页面 -->
            <result name="error">/login.jsp</result>
        </action>
    </package>
</struts>

UserAction.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
package com.action;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Controller;

import com.domain.User;
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.ModelDriven;
import com.service.UserService;

/**
 * 控制层继承ActionSupport,实现模型驱动
 * @author 何军
 * 
 */
@Controller // 该注解告诉Spring这是一个控制器类型的Component
@Scope("prototype") // 把Action交给Spring管理，默认是单例的，该注解指定为Action多例
public class UserAction extends ActionSupport implements ModelDriven<User>{
    
    // 实现模型驱动需要new一个实体类的对象，通过getModel返回 
    private User user = new User();
    
    // 自动装载UserService对象
    @Autowired
    private UserService userService;
    
    // 返回模型user对象
    public User getModel() {
        return user;
    }
    
    // 登录方法
    public String login() {
        // 调用Service层的方法得到用户
        User existUser = userService.login(user);
        // 如果没有得到用户
        if (existUser == null) {
            // 加入错误提示信息
            this.addFieldError("loginFail", "用户名或者密码错误");
            return ERROR;
        } else {
            // 登录成功，将用户信息压入栈中
            ActionContext.getContext().getValueStack().push(existUser);
            return SUCCESS;
        }
    }
}

三.业务逻辑层(UserService)，UserServiceImpl实现UserService中的方法

UserService.java

1
2
3
4
5
6
7
8
9
package com.service;

import com.domain.User;

public interface UserService {

    User login(User user);

}

UserServiceImpl.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package com.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.dao.UserDao;
import com.domain.User;
import com.service.UserService;
// 该注解说明这是一个Service类型的Commpent
@Service 
public class UserServiceImpl implements UserService{
    
    // 自动装载UserDao
    @Autowired
    private UserDao userDao;
    
    public User login(User user) {
        // 通过用户名和密码查找用户
        User existUser = userDao.findUserByUsernamAndPassword(user);
        return existUse;
    }

}

四.数据库操作层(UserDao)，UserDaoImpl实现UserDao中的方法

UserDao.java

1
2
3
4
5
6
7
8
9
package com.dao;

import com.domain.User;

public interface UserDao {

    User findUserByUsernamAndPassword(User user);

}

UserDaoImpl.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
package com.dao.impl;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.hibernate5.HibernateTemplate;
import org.springframework.stereotype.Repository;

import com.dao.UserDao;
import com.domain.User;
// Dao层
@Repository
public class UserDaoImpl implements UserDao{
    
    // 自动装配hibernateTemplate,这个Bean需要在applicationContext.xml中注册
    @Autowired
    private HibernateTemplate hibernateTemplate;
    
    public User findUserByUsernamAndPassword(User user) {
        // hql语句
        String hql = "from User where username=? and password=?";
        // 查找对象
        List<User> users = (List<User>) hibernateTemplate.find(hql, user.getUsername(), user.getPassword());
        if (users.size() > 0) {
            // 查找到的对象用户名和密码唯一，所以如果找到的话，List中的第一个对象就是要找的对象
            return users.get(0);
        }
        return null;
    }

}

五.实体层（User）

User.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
package com.domain;

import java.io.Serializable;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
// 声明实体类映射
@Entity
@Table(name="User")
public class User implements Serializable{
    private Integer id; // id
    private String username; // 用户名
    private String password; // 密码
    
    // 主键
    @Id
    @GeneratedValue(strategy=GenerationType.AUTO) // 主键生成策略
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    
}

六.建立数据库关联

在数据库中创建一个名字为_ssh的数据库
jjdbc.properties

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
jdbc.driver=com.mysql.cj.jdbc.Driver
#\u5B9A\u4E49\u8FDE\u63A5\u7684URL\u5730\u5740\uFF0C\u8BBE\u7F6E\u7F16\u7801\u96C6\uFF0C\u65F6\u95F4\u57DF\uFF0C\u5141\u8BB8\u591A\u6761SQL\u8BED\u53E5\u64CD\u4F5C\u0153
jdbc.url=jdbc:mysql://localhost:3306/_ssh?characterEncoding=utf-8&serverTimezone=UTC&allowMultiQueries=true
#jdbc:mysql://localhost:3306/thcardb?characterEncoding=utf-8&serverTimezone=UTC&allowMultiQueries=true
jdbc.username=root
#jdbc.password=asd123asd
jdbc.password=123
#\u5B9A\u4E49\u521D\u59CB\u8FDE\u63A5\u6570
initialSize=0
#\u5B9A\u4E49\u6700\u5927\u8FDE\u63A5\u6570
maxActive=20
#\u5B9A\u4E49\u6700\u5927\u7A7A\u95F2
maxIdle=20
#\u5B9A\u4E49\u6700\u5C0F\u7A7A\u95F2
minIdle=1
#\u5B9A\u4E49\u6700\u957F\u7B49\u5F85\u65F6\u95F4
maxWait=60000

将数据库相关的全部配置作为Bean交给Spring处理，applicationContext.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-4.3.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
    <!-- 自动扫描包下面的Bean -->
    <context:component-scan base-package="com"/>
     <!-- 加载jdbc的属性文件 -->
    <bean id="propertyConfigurer"
        class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="location" value="classpath:jdbc.properties" />
    </bean>
    <!-- druid配置数据源 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
        init-method="init" destroy-method="close">
        <property name="driverClassName" value="${jdbc.driver}" />
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
        <!-- 初始化连接大小 -->
        <property name="initialSize" value="${initialSize}"></property>
        <!-- 连接池最大数量 -->
        <property name="maxActive" value="${maxActive}"></property>
        <!-- 连接池最大空闲 -->
        <!-- <property name="maxIdle" value="${maxIdle}"></property> -->
        <!-- 连接池最小空闲 -->
        <property name="minIdle" value="${minIdle}"></property>
        <!-- 获取连接最大等待时间 -->
        <property name="maxWait" value="${maxWait}"></property>
    </bean>
    <!-- 配置SessionFactory -->
    <bean id="sessionFactory"
        class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
        <!-- 配置数据源 -->
        <property name="dataSource" ref="dataSource" />
        <!-- 其它hibernate配置 -->
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</prop>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.format_sql">true</prop>
                <prop key="hibernate.hbm2ddl.auto">update</prop>
                <prop key="javax.persistence.validation.mode">none</prop>
            </props>
        </property>
        <property name="packagesToScan" value="com.domain"/>
    </bean>
    <!-- 注册hibernateTemplate这个Bean -->
    <bean id="hibernateTemplate" class="org.springframework.orm.hibernate5.HibernateTemplate">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>
    
</beans>

测试：

  • 启动，自动生成了表

    http://note.youdao.com/noteshare?id=ff74bd55eda6aed2898e6795393c1759&sub=94411C8BB357477B882D067B4F68BF4A

  • 在数据库中加一条数据

    在数据库中加一条数据

  • 输入错误的用户名密码测试

    输入错误的用户名密码测试

  • 输入正确的用户名密码测试

    输入正确的用户名密码测试

总结：

MVC思想是贯穿WEB开发的，回想自己当初刚刚接触WEB开发时，学习thinkphp5框架一脸懵。当时刚刚大一结束，对编程的接触就是用C语言完成了一个通讯录管理程序。用C语言实现了简单的增删改查。接触WEB开发，先学html+css，学得不怎么样，连盒子模型都没有理解透，就开始接触Boostrap框架。后来隔了一个寒假，回去开始学习thinkphp5，连框架的概念都没有的我每天学习十分得痛苦。现在，离我离开实验室应该是4个月。我自己从零开始接触了java，四个月时间，我的进步还是可观的，回想大学这一年，发生的事情真的好多。

emm.坚持原创技术分享，您的支持将鼓励我这个小菜鸡的创作！