目录
一. SSM框架组件
1. SpringMVC:它用于web层,相当于controller(等价于传统的servlet和struts的action),用来处理用户请求。举个例子,用户在地址栏输入http://网站域名/login,那么springmvc就会拦截到这个请求,并且调用controller层中相应的方法,(中间可能包含验证用户名和密码的业务逻辑,以及查询数据库操作,但这些都不是springmvc的职责),最终把结果返回给用户,并且返回相应的页面(当然也可以只返回json/xml等格式数据)。springmvc就是做前面和后面过程的活,与用户打交道!!
2. Spring:太强大了,以至于我无法用一个词或一句话来概括它。但与我们平时开发接触最多的估计就是IOC容器,它可以装载bean(也就是我们java中的类,当然也包括service dao里面的),有了这个机制,我们就不用在每次使用这个类的时候为它初始化,很少看到关键字new。另外spring的aop,事务管理等等都是我们经常用到的。
3. MyBatis:如果你问我它跟鼎鼎大名的Hibernate有什么区别?我只想说,他更符合我的需求。第一,它能自由控制sql,这会让有数据库经验的人,编写的代码能搞提升数据库访问的效率。第二,它可以使用xml的方式来组织管理我们的sql,因为一般程序出错很多情况下是sql出错,别人接手代码后能快速找到出错地方,甚至可以优化原来写的sql。第三,他与Hibernate相比更轻量级。
二. SSM配置过程
1. 创建工程
创建一个Web工程,命名为SSMPZ。Tomcat版本7.0、MySQL版本5.7,用此web工程来开发SSM框架。
2. 引入jar包
需要引入的依赖har包包括支撑SSM框架的jar包 + jstl使用的jar包 + 连接数据库支持的jar包。其下载地址:https://pan.baidu.com/s/17pJUWBwpiQaLahSjWWU0sg 提取码: mcwm (失效私我)。
(1)导入位置:SSMPZ/WebContent/WEB-INF/lib
(2)jar包的作用
spring-expression.RELEASE.jar:Spring表达式语言。
spring-aop.RELEASE.jar : Spring的面向切面编程,提供AOP(面向切面编程)实现。
mybatis.jar:实现mybatis框架的工具包。
mybatis-spring.jar:集合spring与mybatis框架的工具包。
spring-webmvc:webmvc主要是对mvc的支持,包括restful协议
(3)jar包间关系
Spring.jar管理mybatis.jar , 管理方式通过spring-mybatis.jar
Mybatis.jar通过mysql-connector.jar管理mysql
Spring.jar管理整体框架配合
注意:SSM框架中,MyBatis、Spring和mybatis-spring jar包版本匹配兼容的问题。对应规则参照官网:mybatis-spring
3. 配置Spring框架
(1)配置log4j
在src文件夹下创建log4j.properties(提供支持),用于提供Spring容器运行日志,打印java运行过程,也就是运行时显示框Console里的日志内容;目的就是出错时找错误,查看运行过程。log4j.properties内容如下:
# Global logging configuration
# DEBUG
log4j.rootLogger=DEBUG, stdout
# Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n
(2)在src文件夹下创建applicationContext.xml
该文件是Spring核心配置文件,用来初始化创建管理Bean对象。其目的是管理Spring Bean容器,自动创建、取出、赋值所管理的对象。其原理是Spring采用ApplicationContext类来作为Bean容器,其作为BeanFactory类的子接口,在其基础上拓展了功能,在初始化时就创建管理所有的配置的Bean,通过xml文件作为resource。applicationContext.xml基本内容如下:
<?xml version="1.0" encoding="UTF-8"?>
<!--头部标签引用,引入对于xml逻辑的规范,命名空间等配置 -->
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="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
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">
<!-- 标签定义:配置需要Spring进行启动初始化管理注入的Bean对象,spring容器会自动帮你new
<property name="name" value="tom"></property>通过set方法设置属性值
所以相应Bean类必须满足bean定义的规则
-->
<bean id="test" class="com.sm.test.Test">
<property name="name" value="tom"></property>
<property name="age" value="17"></property>
</bean>
</beans>
(3)配置web.xml
该文件配置在Tomcat服务器启动时加载初始化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_3_0.xsd" id="WebApp_ID" version="3.0">
<display-name>SSMPZ</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>
<!-- 配置启动Spring容器 ,使用监听器的方式启动Spring容器ApplicationContext
(1)启动Spring容器
(2)加载初始化配置参数
context-param 配置Spring核心配置文件的路径,告诉tomcat核心文件在哪里,有哪些bean对象在spring容器创建时需要去加载
listener 用来启动Spring容器的监听器,加载核心配置文件,并创建Spring容器,这个容器叫做ApplicationContext
-->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:applicationContext.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- ContextLoaderListener的作用就是启动Web容器时,读取在contextConfigLocation中定义的xml文件,自动装配ApplicationContext的配置信息,并产生WebApplicationContext对象,然后将这个对象放置在ServletContext的属性里,这样我们只要得到Servlet就可以得到WebApplicationContext对象,并利用这个对象访问spring容器管理的bean。
简单来说,就是上面这段配置为项目提供了spring支持,初始化了Ioc容器。-->
</web-app>
(4)运行结果
Console窗口信息输出如下:可以看到Test默认构造方法和set方法中的信息被输出,表示bean对象初始化成功,spring容器配置完成。
4. 配置SpringMVC框架
4.1 SpringMVC运行原理
SpringMVC框架是围绕前端控制器DispatcherServlet类为核心运转的。DispatcherServlet最主要的功能就是拦截来自用户的请求,并将其分配给相应的类(这样的类被称为Handle)处理,并将结果返回给用户。而Handle类要想接收来自前端控制器转发的请求进行处理,有两种方法:
(1)进行处理的类必须实现Controller接口,并通过实现Controller接口中的handleRequest()方法来处理请求;
(2)在Spring2.5开始,可以通过增加注解@Controller和@RequestMapping的注解类型来实现上述中同样的功能;
SpringMVC执行的详细流程如下:
(1)用户向浏览器发送请求,被DispatcherServlet霸道截取,准备分配;
(2)DispatcherServlet对请求进行解析封装,调用HandlerMapping(处理器映射器) , 根据配置或者注解寻找所有相应的Handle类;
(3)DispatcherServlet再将找到的类交给HandlerAdapter(处理器适配器),调用相应的处理方法来处理请求,返回给前端处理器视图资源。
(4)DispatcherServlet将视图资源交由视图解析器处理解析,渲染视图,返回给客户。
4.2 SpringMVC配置过程
4.2.1 启动DispatcherServlet类
在web.xml中定义启动DispatcherServlet类来拦截用户请求,作为SpringMVC框架启动的起点。在web.xml中添加如下配置:
<!--
启动SpringMvc的前端控制器 ,依赖于servlet(servlet处理请求)
org.springframework.web.servlet.DispatcherServlet jar包自带的servlet
init-param 启动时加载DispatcherServlet的初始化核心配置文件资源
load-on-startup 在tomcat启动时加载servlet,1表示优先级,表示第一个创建
url-pattern( *.action/*.do) 所有以.action/.do结尾的url都由
DispatcherServlet拦截 比如 login.action,registre.action
-->
<!--定义servlet类,并提供初始化参数(springmvc.xml)-->
<servlet>
<servlet-name>springDispatcherServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<!--所有url以.action结尾的都由该servlet拦截-->
<servlet-mapping>
<servlet-name>springDispatcherServlet</servlet-name>
<url-pattern>*.action</url-pattern>
</servlet-mapping>
<!-- <url-pattern>/</url-pattern>表示所有请求均由该servlet拦截 -->
4.2.2 配置springMVC核心参数
在src下创建配置springmvc.xml文件,配置springMVC启动时的核心配置参数。包括扫描加载哪些地方的Controller类,启动HandlerMapping处理器映射器,启动HandlerAdapter处理器适配器,启动ViewResolver视图解析器等。springmvc.xml配置如下:
<?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:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-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">
<!-- 配置springmvc,自动扫描某包下的所有类,并且自动生成该包下所有符合要求的类的bean
对象,所谓的符合要求是指使用了相关的注解定义的Controller类,假设我们所有的
Controller注解类都放在com.sm.controller包下
-->
<context:component-scan base-package="com.sm.controller"></context:component-scan><!-- 定义扫描的包为com.sm.controller -->
<mvc:annotation-driven></mvc:annotation-driven><!-- 启用springmvc的注解驱动,这一个标签包含注册处理器映射器,处理器适配器,试图解析器等等 -->
</beans>
注意:早先时间,使用的是标签定义来一个个定义初始化的类即<bean id=" " class=" "></bean>后来我们用扫描包的方法自动扫描所有符合要求的类<context:component-scan base-package="包名">;早先时间,我们使用标签定义来一个个启动映射器,适配器和视图解析器:<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"/>配置annotation类型的映射器.....现在可以使用annotation驱动标签,注册所有的配置。
4.2.3 编写Controller注解类
来进行请求的事务处理(以用户登陆验证为例,暂时不涉及数据库)。在src/com.sm.controller下创建UserController.java
package com.sm.controller;
import java.io.IOException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import org.springframework.http.HttpRequest;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
/*用来处理请求的类必须以Controller结尾
* 使用springmvc的扫描器通过springmvc.xml扫描初始化符合要求的类,来决定这个类响应什么请求
*/
/* 第一个注解 :org.springframework.stereotype.Controller; @Controller放在类前表示该类处理请求
* 告诉springmvc扫描器,这个类需要加载处理请求,相当于实现了Controller接口
* springmvc扫描器扫描完成后,会在spring容器里自动创建该类的bean对象
* 避免了标签定义一个个创建类,通过扫描其扫描创建
*/
@Controller
public class UserController {
public UserController() {
System.out.println("UserController is started!");
}
/*
* 第二个注解@RequestMapping
* 放在处理请求的方法前,相当于实现了requestHandle方法
* RequestMapping注解配置URL与处理方法之间的映射关系即login.action的url交由login方法处理
*比如 http://localhost:8080/SSM/login.action由servlet分配给login()方法处理
*
*/
@RequestMapping("login.action")
public String login(String username,String pwd,HttpServletRequest request,HttpServletResponse response) throws IOException {//处理用户登陆请求操作
//获取来自客户端的参数
//1.request.getParameter("")可以获取
//2.其他方法 :使用与表单一一对应参数名,可以自动装配!(常用)
HttpSession session = request.getSession();
if(!username.equals("xiaoming")) {
session.setAttribute("error", "username is wrong");
return "login.jsp";
}
if(!pwd.equals("123")) {
session.setAttribute("error", "password is wrong");
return "login.jsp";
}
session.setAttribute("username", username);
return "welcome.jsp";
}
}
注意:在类前增加@Controller注释,在方法前增加@RequestMapping("url")注释。客户端与Controller的参数传递方式:
(1)直接用request和response获取
@RequestMapping("login.action")
public String login(HttpServletResponse response,HttpServletRequest request){}
(2)同名参数直接获取
//Post+get : 用与表单同名参数自动装填获取
@RequestMapping("login.action")
public String login(String username,String pwd,HttpServletResponse response,HttpServletRequest request){}
(3)使用对象自动注入
//类的属性的名字与表单参数名字相同即可,类符合bean规则
@RequestMapping("login.action")
public String login(User user,HttpServletResponse response,HttpServletRequest request) {//处理用户登陆请求操作}
4.2.4 Hnalder的返回值
(1)void 没有返回值 : 要求Handler必须用response进行返回
(2)String字符串: View视图名,springmvc会通过视图解析器生成相应页面,返回给客户端。但此处缺少model(数据) , 可以通过session对象携带参数
(3)ModelAndView : 可以通过ModelAndView对象封装视图和数据:
//新建对象
ModelAndView mv = new ModelAndView();
//携带数据参数,类似session.setArbritube
mv.addObject("error","账号或密码错误!!!");
//设置视图
mv.setViewName("login.jsp");
return mv;
4.2.5 编写页面
编写login.jsp页面和welcome.jsp页面(在WebContent下)。
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>login</title>
</head>
<body>
<form action="login.action" method="post">
<Input type="text" name="username"><br>
<input type="password" name="pwd"><br>
<font color="red">${error }</font>
<input type="submit" name="button" value="登陆">
</form>
</body>
</html>
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>welcome</title>
</head>
<body>
Welcome,${username }
</body>
</html>
4.2.6 运行结果
可以看到我们定义的UserController已经启动了:用户名错误情况
成功登陆情况
5. 配置MyBatis框架
5.1 创建数据库
在MySQL中创建数据库skmall,创建表user,字段类型如下:
5.2 创建映射文件
在src文件下创建Mybatis的核心映射文件SqlMapConfig.xml,配置如下:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<!-- DOCTYPE 指定文件的解析方式
configuration: 配置
针对于MyBatis3的配置
mybatis核心配置文件
-->
<configuration>
</configuration>
5.3 添加配置信息
使用Spring管理Mybatis:在Spring核心配置文件applicationContext.xml中添加配置信息。
<!-- Spring 管理Mybatis的配置 -->
<!-- 数据源 -->
<!-- SqlSession工厂 -->
<!-- Mapper的自动扫描 -->
<!-- 配置数据源
通过C3P0的dataSource(连接池)创建一个Bean
-->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/skmall?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC"></property>
<property name="user" value="root"></property>
<property name="password" value="my060321"></property>
</bean>
<!-- 配置SqlSessionFactory 数据库会话工厂-->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"></property>
<!-- 指定MyBatis的核心配置文件 -->
<property name="configLocation" value="classpath:SqlMapConfig.xml">
</property>
</bean>
<!-- 扫描Mapper下的所有接口
定义Spring管理使用Mybatis时要扫描的包
-->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="sqlSessionFactory" ref="sqlSessionFactory"></property>
<property name="basePackage" value="com.sm.dao"></property>
</bean>
注意:在xml文件中,分号要使用& 代替,否则报错。
5.4 定义实体类
定义包com.sm.pojo存放所有的实体类。用来给数据库承载信息,在xml中传递信息,收集结果。具体的在包下定义类 User.java专门用来传递,存放用户信息。要求:
* 1.实体类名与数据库表名一样
* 2.实体类属性与数据表字段对应(属性名与字段名一样,数据类型匹配)
* 3.实体类属性全部私有,并且提供public的Get和Set方法(bean规则)
* 4.实体类必须有一个无参构造方法
package com.sm.pojo;
public class User {
private Integer uid;
private String username;
private String pwd;
private Float money;
//
public User() {
}
public Integer getUid() {
return uid;
}
public void setUid(Integer uid) {
this.uid = uid;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPwd() {
return pwd;
}
public void setPwd(String pwd) {
this.pwd = pwd;
}
public Float getMoney() {
return money;
}
public void setMoney(Float money) {
this.money = money;
}
}
5.5 定义Dao层
创建包com.sm.dao,存放所有的Dao层接口Mapper和对应的xml配置。定义持久层Mapper,只定义好接口(这里的接口不用有实现类就可使用创建对象 ,基于动态代理实现),一个Mapper对应一个xml配置,利用mapper方法在xml中配置来管理数据库。
注意:Mapper接口和xml配置文件名称必须相同一致。
(1)UserMapper.java接口(专门用来进行用户的数据库访问)--定义方法
package com.sm.dao;
import com.sm.pojo.User;
public interface UserMapper {
//根据账号查询用户是否存在的方法,若存在则将该用户信息保存到User类做进一步验证
public User SelectByUserName(String username);
}
(2)UserMapper.xml配置接口
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.sm.dao.UserMapper">
<!-- 根据方法中对数据库的操作来使用不同的标签
SQL语句查询,使用selete标签
插入使用 insert
更新使用update
-->
<!-- id为对应方法名必须完全相同!,parameterType为参数查询对象来源+对象中的属性 ,resultType返回结果对象-->
<!-- 根据账号来查询 -->
<select id="SelectByUserName" parameterType="String" resultType="com.skmall.pojo.User">
select * from user where username = #{username}
</select>
</mapper>
5.6 定义Service层
为了将Controller层与底层事务操作实现分离,定义Service层,作为Controller层与Dao层交互的媒介。为了自动注入Service,需要在spring容器applicationContext.xml中配置:
<!-- 扫描Service层 -->
<context:component-scan base-package="com.sm.service.impl"></context:component-scan>
为了表明service层,需要增加注解@Service;除此之外,因为用户登陆分为:用户不存在、密码错误、登陆成功三种情况,单单用null来判断是不足够的,所以我们采用抛出异常的方法来检测结果。
(1)定义com.sm.service包存放所有service接口
(2)定义com.sm.service.impl包存放所有接口实现类
(3)创建IUserService.java接口和实现类UserServiceImpl.java类进行事务处理
(4)修改Controller如下,加入MyBatis:
package com.sm.controller;
import java.io.IOException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpRequest;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
import com.sm.pojo.User;
import com.sm.service.IUserService;
/*用来处理请求的类必须以Controller结尾
* 使用springmvc的扫描器通过springmvc.xml扫描初始化符合要求的类,来决定这个类响应什么请求
*/
/* 第一个注解 :org.springframework.stereotype.Controller; @Controller放在类前表示该类处理请求
* 告诉springmvc扫描器,这个类需要加载处理请求,相当于实现了Controller接口
* springmvc扫描器扫描完成后,会在spring容器里自动创建该类的bean对象
* 避免了标签定义一个个创建类,通过扫描其扫描创建
*/
@Controller
public class UserController {
public UserController() {
System.out.println("UserController is started!");
}
//自动注入IUserService类,避免new,由Spring容器自动装配
//自动注入Service层对象,首先要配置到Spring中去管理!!才能取到!
@Autowired
IUserService iUserService;
@RequestMapping("login.action")
public ModelAndView login(User user,HttpServletRequest request,HttpServletResponse response) {//处理用户登陆请求操作
HttpSession session = request.getSession();
ModelAndView mv = new ModelAndView();
try {
User loginuser = iUserService.login(user);// 请求service层结果,处理结果
mv.addObject("loginuser",loginuser);
mv.setViewName("welcome.jsp");
}catch(Exception e) {
mv.addObject("error", e.getMessage());
mv.setViewName("login.jsp");
}
return mv;
}
}
(5)编码service接口IUserService.java
package com.sm.service;
import com.sm.pojo.User;
public interface IUserService {
User login(User user) throws Exception;
}
(6)编码实现类UserServiceImpl.java
package com.sm.service.impl;
import com.sm.service.IUserService;
import org.springframework.beans.factory.annotation.Autowired;
import com.sm.dao.UserMapper;
import com.sm.pojo.User;
/*
* 实现接口IUserService 的类
*
* 将Service层的对象交给Spring管理
* 1.在Service层的实现类上加注解@Service
*
* 2.在Spring核心配置里,扫描该包
*/
@Service
public class UserServiceImpl implements IUserService{
//自动注入Mapper,与数据库交互
@Autowired
UserMapper userMapper;
@Override
public User login(User user) throws Exception {
User loginUser = userMapper.SelectByUserName(user.getUsername());
if(loginUser!=null) {
if(!user.getPwd().equals(loginUser.getPwd())) {
throw new Exception("密码错误!");
}
}
else {
throw new Exception("用户不存在!");
}
return loginUser;
}
}
6. SSM框架开发顺序
运行结果如下:
用户不存在:可以看到运行日志里数据库中查询到0条记录
登陆成功:数据库中查询到一条记录
三. 其他配置
1. 编码过滤器
用于解决页面乱码问题。相当于request.setEncoding和response.setEncoding,不用在每个页面手动设置了。在web.xml加入如下片段:
<!-- 编码过滤器,解决乱码 -->
<filter>
<filter-name>characterEncodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>characterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
2. MD5加密
通过MessageDigest类可以进行MD5加密操作(MD5加密是不可逆的)。目的是由于用户密码显式保存在数据库中,安全性很低。所以我们通过MD5加密对用户密码进行加密后保存,会大幅度提高用户密码的安全性。
(1)对加密操作进行封装,在src文件夹下创建包com.sm.util,在包内创建类MD5Util.java
package com.sm.Util;
import java.security.MessageDigest;
import java.util.Base64;
import java.util.Base64.Encoder;
public class MD5util {
public static String getMD5(String str) {
// MD5加密数据库数据
String newstr = null;
try {
//确定计算方法
MessageDigest md5=MessageDigest.getInstance("MD5");
//加密后的字符串
newstr=encryptBASE64(md5.digest(str.getBytes("utf-8")));
} catch (Exception e) {
// TODO: handle exception
}
return newstr;
}
private static String encryptBASE64(byte[] data) {
// BASE64Encoder encoder = new BASE64Encoder();
// String encode = encoder.encode(data);
// 从JKD 9开始rt.jar包已废除,从JDK 1.8开始使用java.util.Base64.Encoder
Encoder encoder = Base64.getEncoder();
String encode = encoder.encodeToString(data);
return encode;
}
public static void main(String[] args) {
String string = "123456";
String str2 = getMD5(string);
/*
* 1. 改变顺序
* 倒序
* 奇偶位调换
* 2. 字符替换
* 1->A
* 2->3
*
* 26*26*10*10
*/
System.out.println(str2);
}
}
(2)登陆验证:将登陆密码加密,同数据库中已经加密的密码进行比对,若相同即为密码一致
@RequestMapping("login.action")
public ModelAndView login(User user,HttpServletResponse response,HttpServletRequest request) {//处理用户登陆请求操作
try {
user.setPwd(MD5Util.getMD5(user.getPwd()));//输入密码加密
User loginUser = iUserService.login(user);
}
}
(3)数据库显示