SSM框架（二） 环境配置与整合

目录

一. SSM框架组件

二. SSM配置过程

1. 创建工程

2. 引入jar包

3. 配置Spring框架

4. 配置SpringMVC框架

4.1 SpringMVC运行原理 

4.2 SpringMVC配置过程

5. 配置MyBatis框架

5.1 创建数据库

5.2 创建映射文件

5.3 添加配置信息

5.4 定义实体类

5.5 定义Dao层

5.6 定义Service层

6. SSM框架开发顺序

三. 其他配置

1. 编码过滤器

2. MD5加密

---

一. 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&amp;characterEncoding=UTF-8&amp;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文件中，分号要使用&amp; 代替，否则报错。

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）数据库显示