0
点赞
收藏
分享

微信扫一扫

springmvc_day03_ssm三大框架整合_拦截器

代码小姐 2022-09-19 阅读 22


文章目录

  • ​​一、今日内容​​
  • ​​二、整合SSM​​
  • ​​1、整合思路​​
  • ​​2、引入依赖和依赖分析​​
  • ​​3、表和实体类的创建​​
  • ​​4、Dao层的编写​​
  • ​​a、引入依赖​​
  • ​​b、接口编写​​
  • ​​c、配置文件​​
  • ​​d、测试​​
  • ​​e. spring 与mybatis整合操作​​
  • ​​1) 添加依赖​​
  • ​​2) 删除了SqlMapConfig.xml​​
  • ​​3) 添加一个applicationContext.xml文件​​
  • ​​4) 测试​​
  • ​​5、Service层编写​​
  • ​​a、引入依赖 pom.xml​​
  • ​​b、接口编写 AccountService.java​​
  • ​​c、接口实现类 AccountServiceImpl.java​​
  • ​​d、配置文件,在applicationContext.xml中添加​​
  • ​​e、测试​​
  • ​​f、最终applicationContext.xml (spring+mybatis )(springmvc还是有单独的xml)​​
  • ​​6、web层编写​​
  • ​​a、引入依赖​​
  • ​​b、配置文件:springmvc.xml​​
  • ​​c. 控制类的创建​​
  • ​​7、编写web.xml​​
  • ​​8、编写页面​​
  • ​​a、查询页面编写​​
  • ​​b 、添加账户​​
  • ​​c、删除操作​​
  • ​​d、更新操作​​
  • ​​Demo整理​​
  • ​​9、引入日志​​
  • ​​三、拦截器​​
  • ​​1、拦截器的作用​​
  • ​​2、拦截器的代码​​
  • ​​a. 引入依赖​​
  • ​​b.spring-mvc.xml​​
  • ​​c. 创建拦截器类​​
  • ​​3、多个拦截器测试​​
  • ​​4、在ssm中使用拦截器示例​​
  • ​​a、登录页面​​
  • ​​b、创建拦截器类 LoginInterceptor.java​​
  • ​​c、spring-mvc.xml 添加拦截器配置​​
  • ​​四、小结​​

一、今日内容

  1. 整合ssm框架
  2. 拦截器

二、整合SSM

1、整合思路

a. SSM介绍
springmvc+ spring + mybatis=ssm
mybatis 持久层的CURD
spring 业务层 IOC、DI(解耦) 和AOP(事务问题), ssm 综合练习中:aop解决日志问题
springMVC 表现层 MVC的操作
b. 整合使用的技术
1). Spring 5.0.2
2). mybatis 3.4.5
3). SpringMVC 5.0.2
4). log4J2 2.9.1
5). bootstrap 3.3.5
6). jquery 1.9.1
......
c.

2、引入依赖和依赖分析

a. Spring相关的
1). spring-context : Spring容器
2). spring-tx : Spring事务
3). spring-jdbc : SpringJDBC
4). spring-test : Spring单元测试
5). spring-webmvc : SpringMVC
b. mybatis相关的
1). mybatis : mybatis核心
2). mybatis-spring :mybatis与spring整合
3). 切面相关的
aspectjweaver : AOP切面
4). 数据源相关(选择使用):
c3p0
commons-dbcp
spring自带的数据源
5) 单元测试相关的:
junit : 单元测试,与spring-test放在一起做单元测试
6) ServletAPI相关的
jsp-api : jsp页面使用request等对象
servlet-api : java文件使用request等对象
7) 日志相关的:
log4j-core : log4j2核心包
log4j-api : log4j2的功能包
log4j-web : web项目相关日志功能
slf4j-api : 另外一种日志包,
slf4j:Simple Logging Facade for Java为java做简单的日志记录此处和log4j一起
log4j-slf4j-impl : slf4j的log4j实现类,也就是说slf4j的日志记录功能由log4j实现
log4j-jcl : 程序运行的时候检测用了哪种日志实现类现在叫Apache Common Logging
8) 数据库相关的
mysql-connector-java : mysql的数据库驱动包
ojdbc.jar : oracle的驱动jar包
9) 页面表达式
JSTL : JSTL标签库必须jar包 基础功能
standard : JSTL标签库的必须jar包 进阶功能
10) 文件上传
commons-fileupload : 上传插件
commons-io :

3、表和实体类的创建

1. 
2. 实体类
public class Account {
private Integer id;
private String name;
private Float money;
}

4、Dao层的编写

a、引入依赖

<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
<!--lombok-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.4</version>
</dependency>

<!--持久层-->
<!--mybatis-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.4.5</version>
</dependency>
<!--mysql驱动-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.36</version>
</dependency>
<!--数据源-->
<dependency>
<groupId>c3p0</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.1.2</version>
</dependency>
<dependency>
<groupId>commons-dbcp</groupId>
<artifactId>commons-dbcp</artifactId>
<version>1.4</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.0.2.RELEASE</version>
</dependency>
</dependencies>

b、接口编写

public interface AccountDao {

@Select("select * from account")
public List<Account> findAll();

@Select("select * from Account where id=#{id}")
public Account findById(Integer id);

@Select("insert into account values(null,#{name},#{money})")
public void save(Account account);

@Select("update account set name=#{name},money=#{money} where id=#{id} ")
public void update(Account account);

@Select("delete from account where id=#{id}")
public void delById(Integer id);

}

c、配置文件

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">
<configuration>
<!--引入数据的属性文件-->
<properties resource="jdbc.properties"></properties>
<!--注解不需要别名-->
<!--数据库的环境-->
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="${jdbc.driver}"/>
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</dataSource>
</environment>
</environments>
<mappers>
<!--引入一个包 就引入了该包中所有接口或xml 直接面向接口编程-->
<package name="cn.ahpu.dao"></package>
<!--xml方式时表对应的xml名字和路径得与接口完全相同,注解方法没有xml不用考虑 此核心xml肯定在根目录下-->
</mappers>
</configuration>

d、测试

TestDao.java

public class TestDao {

@Test
public void test(){
//配置文件输入流对象
InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream("SqlMapConfig.xml");
//创建session工厂
SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
//获取一个sqlSession对象
SqlSession sqlSession = sessionFactory.openSession();
//获取代理对象
AccountDao accountDao = sqlSession.getMapper(AccountDao.class);
//调用方法(一般在services层)
List<Account> accountList = accountDao.findAll();
for (Account account : accountList) {
System.out.println(account);
}
sqlSession.close();
}

}

e. spring 与mybatis整合操作

1) 添加依赖

<!--整合mybatis与spring需要的jar-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.3.1</version>
</dependency>
<!--spring的核心-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.0.2.RELEASE</version>
</dependency>

2) 删除了SqlMapConfig.xml

springmvc_day03_ssm三大框架整合_拦截器_spring

3) 添加一个applicationContext.xml文件

applicationContext.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"
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.xsd">

<!--引入属性文件-->
<context:property-placeholder location="jdbc.properties"></context:property-placeholder>
<!--创建数据源对象 此处用spring自带的-->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="url" value="${jdbc.url}"></property>
<property name="driverClassName" value="${jdbc.driver}"></property>
<property name="username" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</bean>

<!--先创建SqlSessionFactory对象 mybatis.spring整合的工厂类-->
<bean id="SqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<!--注入数据源 然后就会自动封装了-->
<property name="dataSource" ref="dataSource"></property>

<!--还有一大堆零散的配置 如缓存 取别名 可以直接在此文件内配 也可以仍然保留sqlMapconfig然后此处引入即可 不过一般数据源都是放在此文件内了-->
<!--方法一:引入sqlMapConfig.xml文件-->
<!--<property name="configLocation" value="classpath:SqlMapConfig.xml"></property>-->

<!--方法二:直接配置-->
<!--eg:别名映射 注意属性方式配置-->
<!--<property name="typeAliasesPackage" value="cn.ahpu.domain"></property>-->
<!--eg:类似的还有其他一大堆属性-->
<!--<property name="configurationProperties" value=""></property>-->
</bean>

<!--扫描dao层接口包 创建动态代理对象 存入IOC容器中 首先需要sqlSession对象 因此在上面创建了工厂-->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<!--指定dao层接口的包名即可-->
<property name="basePackage" value="cn.ahpu.dao"></property>
</bean><!--这么一来 框架会自动帮你实现接口 容器中一定存在接口实现了 也即一定存在接口类型的类了 接口就可以直接调用方法了-->

</beans>

4) 测试

@Test
public void testMybatisAndSpring(){
ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
AccountDao accountDao = ac.getBean(AccountDao.class);//根据类型获取 框架帮你实现 实现类肯定在容器中了
List<Account> accountList = accountDao.findAll();
for (Account account : accountList) {
System.out.println(account);
}
System.out.println("--------------------");
Account account = accountDao.findById(4);
System.out.println(account);
}

springmvc_day03_ssm三大框架整合_拦截器_spring_02

5、Service层编写

a、引入依赖 pom.xml

<!--事务相关-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>5.0.2.RELEASE</version>
</dependency>
<!--AOP切面相关-->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.9</version>
</dependency>
<!--spring与junit整合的测试包-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.0.2.RELEASE</version>
</dependency>

b、接口编写 AccountService.java

public interface AccountService {

public List<Account> findAll();

public Account findById(Integer id);

public void save(Account account);

public void update(Account account);

public void delById(Integer id);

}

c、接口实现类 AccountServiceImpl.java

@Service
public class AccountServiceImpl implements AccountService {

@Autowired //spring帮你实现了实现类 并存放在IOC容器中
AccountDao accountDao;

@Override
public List<Account> findAll() {
return accountDao.findAll();
}

@Override
public Account findById(Integer id) {
return accountDao.findById(id);
}

@Override
public void save(Account account) {
accountDao.save(account);
}

@Override
public void update(Account account) {
accountDao.update(account);
}

@Override
public void delById(Integer id) {
accountDao.delById(id);
}
}

d、配置文件,在applicationContext.xml中添加

包的注解扫描 和 声明式事务

<!--业务层配置开始-->
<!--扫描包内注解 对于标记了某些注解的类也给予创建-->
<context:component-scan base-package="cn.ahpu.service"></context:component-scan>

<!--声明式事务-->
<!--1. 事务管理类对象-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!--注入:数据源对象-->
<property name="dataSource" ref="dataSource"></property>
</bean>
<!--2. 事务增强(过滤对象) 对transactionManager再小小封装下-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<!--查询方法 不必拦截 因为只读 事务可有可无 有事务加入事务执行 没有事务就非事务执行-->
<tx:method name="find*" read-only="true" propagation="SUPPORTS"/>
<tx:method name="query*" read-only="true" propagation="SUPPORTS"/>
<tx:method name="get*" read-only="true" propagation="SUPPORTS"/>

<!--其他所有方法都必须要事务 统一配置 -->
<!--其他方法:非只读事务 若没有事务,创建一个事务,若有事务,加入事务执行 -->
<tx:method name="*" read-only="false" propagation="REQUIRED"></tx:method>
</tx:attributes>
</tx:advice>
<!--3. aop配置;切面配置-->
<aop:config>
<aop:advisor advice-ref="txAdvice" pointcut="execution(* cn.ahpu.service.impl.*.*(..))"></aop:advisor>
</aop:config>

e、测试

TestService.java

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class TestService {

@Autowired
AccountService accountService;

@Test
public void test(){
List<Account> accountList = accountService.findAll();
for (Account account : accountList) {
System.out.println(account);
}
}
}

f、最终applicationContext.xml (spring+mybatis )(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: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.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

<!--持久层配置开始-->
<!--引入属性文件-->
<context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
<!--创建数据源对象 此处用spring自带的-->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="url" value="${jdbc.url}"></property>
<property name="driverClassName" value="${jdbc.driver}"></property>
<property name="username" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</bean>

<!--先创建SqlSessionFactory对象 mybatis.spring整合的工厂类-->
<bean id="SqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<!--注入数据源 然后就会自动封装了-->
<property name="dataSource" ref="dataSource"></property>

<!--还有一大堆零散的配置 如缓存 取别名 可以直接在此文件内配 也可以仍然保留sqlMapconfig然后此处引入即可 不过一般数据源都是放在此文件内了-->
<!--方法一:引入sqlMapConfig.xml文件-->
<!--<property name="configLocation" value="classpath:SqlMapConfig.xml"></property>-->

<!--方法二:直接配置-->
<!--eg:别名映射 注意属性方式配置-->
<!--<property name="typeAliasesPackage" value="cn.ahpu.domain"></property>-->
<!--eg:类似的还有其他一大堆属性-->
<!--<property name="configurationProperties" value=""></property>-->
</bean>

<!--扫描dao层接口包 创建动态代理对象 存入IOC容器中 首先需要sqlSession对象 因此在上面创建了工厂-->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<!--指定dao层接口的包名即可-->
<property name="basePackage" value="cn.ahpu.dao"></property>
</bean><!--这么一来 框架会自动帮你实现接口 容器中一定存在接口实现了 也即一定存在接口类型的类了 接口就可以直接调用方法了-->

<!--持久层配置结束-->

<!--业务层配置开始-->
<!--扫描包内注解 对于标记了某些注解的类也给予创建-->
<context:component-scan base-package="cn.ahpu.service"></context:component-scan>

<!--声明式事务-->
<!--1. 事务管理类对象-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!--注入:数据源对象-->
<property name="dataSource" ref="dataSource"></property>
</bean>
<!--2. 事务增强(过滤对象) 对transactionManager再小小封装下-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<!--查询方法 不必拦截 因为只读 事务可有可无 有事务加入事务执行 没有事务就非事务执行-->
<tx:method name="find*" read-only="true" propagation="SUPPORTS"/>
<tx:method name="query*" read-only="true" propagation="SUPPORTS"/>
<tx:method name="get*" read-only="true" propagation="SUPPORTS"/>

<!--其他所有方法都必须要事务 统一配置 -->
<!--其他方法:非只读事务 若没有事务,创建一个事务,若有事务,加入事务执行 -->
<tx:method name="*" read-only="false" propagation="REQUIRED"></tx:method>
</tx:attributes>
</tx:advice>
<!--3. aop配置;切面配置-->
<aop:config>
<aop:advisor advice-ref="txAdvice" pointcut="execution(* cn.ahpu.service.impl.*.*(..))"></aop:advisor>
</aop:config>

</beans>

6、web层编写

a、引入依赖

<!--springmvc-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.0.2.RELEASE</version>
</dependency>
<!--servlet相关-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jsp-api</artifactId>
<version>2.0</version>
<scope>provided</scope>
</dependency>

b、配置文件: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/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd">

<!--扫描包,创建类对象-->
<context:component-scan base-package="cn.ahpu.controller"></context:component-scan>
<!--视图解析器-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/pages/"></property>
<property name="suffix" value=".jsp"></property>
</bean>
<!--注解驱动-->
<mvc:annotation-driven></mvc:annotation-driven>
<!--静态资源放行-->
<!--<mvc:resources mapping="/js/*" location="/js/"></mvc:resources>-->
<!--静态资源全部放行 web.xml里配置成/* 也可以-->
<mvc:default-servlet-handler></mvc:default-servlet-handler>

<!--拦截器-->

<!--自定义类型转换器(可有可无)-->

<!--文件上传-->

</beans>

c. 控制类的创建

AccountController.java

@Controller
@RequestMapping("/account")
public class AccountController {

@Autowired
AccountService accountService;

@RequestMapping("/findAll")
public ModelAndView findAll(){
ModelAndView modelAndView = new ModelAndView();
//添加数据
modelAndView.addObject("accountList",accountService.findAll());
//指定返回页面
modelAndView.setViewName("show");

return modelAndView;
}
}

7、编写web.xml

<!DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
<display-name>Archetype Created Web Application</display-name>
<!--配置一个全局参数:指定spring容器的xml-->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:applicationContext.xml</param-value>
</context-param>

<!--编码过滤器-->
<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><!--仅限post请求乱码处理-->
</init-param>
</filter>
<filter-mapping>
<filter-name>CharacterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

<!--配置监听器:创建spring容器对象 就是加载applicationContext.xml 前面还有一行配置-->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

<!--前端控制器-->
<servlet>
<servlet-name>DispatcherServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!--指定配置文件的路径-->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring-mvc.xml</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>DispatcherServlet</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>

8、编写页面

bootstrap 文档网站:https://www.w3cschool.cn/bootstrap/

a、查询页面编写

1. 引入bootstrap资源

springmvc_day03_ssm三大框架整合_拦截器_spring_03


2. jstl标签的依赖

pom.xml

<!--jstl标签库-->
<dependency>
<groupId>jstl</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
<dependency>
<groupId>taglibs</groupId>
<artifactId>standard</artifactId>
<version>1.1.2</version>
</dependency>

3. show.jsp

<%--
Created by IntelliJ IDEA.
User: Administrator
Date: 2020/4/28
Time: 11:23
To change this template use File | Settings | File Templates.
--%>
<%@ page isELIgnored="false" contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
<title>所有账户</title>
<!-- 引入CSS样式 -->
<link rel="stylesheet" href="${pageContext.request.contextPath}/css/bootstrap.min.css">
</head>
<body>
<div class="container">
<table class="table table-bordered">
<caption>所有账户</caption>
<thead>
<tr>
<th>编号</th>
<th>账户名称</th>
<th>余额</th>
</tr>
</thead>
<tbody>
<%--要提前引入头和jstl所需的jar--%>
<c:forEach items="${accountList}" var="account">
<tr>
<td>${account.id}</td>
<td>${account.name}</td>
<td>${account.money}</td>
</tr>
</c:forEach>
</tbody></table></div>

</body>
<!-- 引入JS文件 -->
<script type="text/javascript" src="${pageContext.request.contextPath}/js/jquery-1.9.1.js"></script>
<script type="text/javascript" src="${pageContext.request.contextPath}/js/bootstrap.min.js"></script>

</html>

4、controller findAll

@Controller
@RequestMapping("/account")
public class AccountController {

@Autowired
AccountService accountService;

@RequestMapping("/findAll")
public ModelAndView findAll(){
ModelAndView modelAndView = new ModelAndView();
//添加数据
modelAndView.addObject("accountList",accountService.findAll());
//指定返回页面
modelAndView.setViewName("show");

return modelAndView;
}
}

springmvc_day03_ssm三大框架整合_拦截器_spring_04

b 、添加账户

show.jsp修改

springmvc_day03_ssm三大框架整合_拦截器_xml_05


add.jsp

<%--
Created by IntelliJ IDEA.
User: Administrator
Date: 2020/4/28
Time: 12:10
To change this template use File | Settings | File Templates.
--%>
<%@ page isELIgnored="false" contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>添加账户</title>
<!-- 引入CSS样式 -->
<link rel="stylesheet" href="${pageContext.request.contextPath}/css/bootstrap.min.css">
</head>
<body>
<div class="container">
<br>
<form class="form-horizontal" role="form" action="${pageContext.request.contextPath}/account/save" method="post">
<div class="form-group">
<label for="name" class="col-sm-2 control-label">账户名</label>
<div class="col-sm-10">
<input type="text" class="form-control" id="name" name="name"
placeholder="请输入账户名">
</div>
</div>
<div class="form-group">
<label for="money" class="col-sm-2 control-label">余额</label>
<div class="col-sm-10">
<input type="text" class="form-control" id="money" name="money"
placeholder="请输入余额">
</div>
</div>
<div class="form-group">
<div class="col-sm-offset-2 col-sm-10 ">
<button type="submit" class="btn btn-default">添加</button>
</div>
</div></form></div>
</body>
<!-- 引入JS文件 -->
<script type="text/javascript" src="${pageContext.request.contextPath}/js/jquery-1.9.1.js"></script>
<script type="text/javascript" src="${pageContext.request.contextPath}/js/bootstrap.min.js"></script>

</html>

Controller

@RequestMapping("/save")
public String save(Account account){
accountService.save(account);
return "redirect:findAll";//直接转到findAll方法去查询所有 多好多方便 因为不需要传数据 重定向比较好
//此处不要写forword请求转发 会导致刷新重新添加 重定向就没有这问题
//更新数据库之后一定是重定向
}

c、删除操作

show.jsp 添加按钮

<a href="${pageContext.request.contextPath}/account/delById?id=${account.id}"
class="fa fa-remove"style="font-size:20px;color:red"></a>

controller

@RequestMapping("/delById")
public String delById(Integer id){
accountService.delById(id);
return "redirect:findAll";//修改了数据库最好重定向
}

d、更新操作

show.jsp 添加按钮

<%--修改无法直接传递那么多数据 不如传个id去查再回显--%>
<a href="${pageContext.request.contextPath}/account/updateUI?id=${account.id}"
class="fa fa-edit"style="font-size:20px;color:red"></a>

controller updateUI 回显

@RequestMapping("/updateUI")
public ModelAndView updateUI(Integer id){
ModelAndView modelAndView = new ModelAndView();
Account account = accountService.findById(id);
modelAndView.addObject("account",account);
modelAndView.setViewName("edit");
return modelAndView;
}

edit.jsp 回显页面

<%@ page isELIgnored="false" contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>添加账户</title>
<!-- 引入CSS样式 -->
<link rel="stylesheet" href="${pageContext.request.contextPath}/css/bootstrap.min.css">
</head>
<body>
<div class="container">
<br>
<form class="form-horizontal" role="form" action="${pageContext.request.contextPath}/account/update" method="post">
<%--更新需要id 用隐藏域保存提交--%>
<input type="hidden" value="${account.id}" name="id">
<div class="form-group">
<label for="name" class="col-sm-2 control-label">账户名</label>
<div class="col-sm-10">
<input type="text" class="form-control" id="name" name="name" value="${account.name}"
placeholder="请输入账户名">
</div>
</div>
<div class="form-group">
<label for="money" class="col-sm-2 control-label">余额</label>
<div class="col-sm-10">
<input type="text" class="form-control" id="money" name="money" value="${account.money}"
placeholder="请输入余额">
</div>
</div>
<div class="form-group">
<div class="col-sm-offset-2 col-sm-10 ">
<button type="submit" class="btn btn-default">修改</button>
</div>
</div></form></div>
</body>
<!-- 引入JS文件 -->
<script type="text/javascript" src="${pageContext.request.contextPath}/js/jquery-1.9.1.js"></script>
<script type="text/javascript" src="${pageContext.request.contextPath}/js/bootstrap.min.js"></script>
</html>

controller 执行修改

@RequestMapping("/update")
public String update(Account account){
accountService.update(account);
return "redirect:findAll";
}

Demo整理

springmvc_day03_ssm三大框架整合_拦截器_spring_06


springmvc_day03_ssm三大框架整合_拦截器_xml_07


springmvc_day03_ssm三大框架整合_拦截器_xml_08


show.jsp

<%--
Created by IntelliJ IDEA.
User: Administrator
Date: 2020/4/28
Time: 11:23
To change this template use File | Settings | File Templates.
--%>
<%@ page isELIgnored="false" contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
<title>所有账户</title>
<!-- 引入CSS样式 -->
<link rel="stylesheet" href="${pageContext.request.contextPath}/css/bootstrap.min.css">
<link rel="stylesheet" href="https://cdn.staticfile.org/font-awesome/4.7.0/css/font-awesome.css">
</head>
<body>
<div class="container">
<table class="table table-bordered">
<caption>
<%--按钮直接复制样式就行了 外层标签是啥都行--%>
<a href="${pageContext.request.contextPath}/pages/add.jsp" class="btn btn-success">添加</a>
</caption>
<thead>
<tr>
<th>编号</th>
<th>账户名称</th>
<th>余额</th>
<th>操作</th>
</tr>
</thead>
<tbody>
<%--要提前引入头和jstl所需的jar--%>
<c:forEach items="${accountList}" var="account" varStatus="i">
<tr>
<td>${i.count}</td><%--使得一直都是按123456的顺序排列--%>
<td>${account.name}</td>
<td>${account.money}</td>
<td>
<a href="${pageContext.request.contextPath}/account/delById?id=${account.id}"
class="fa fa-remove"style="font-size:20px;color:red"></a>
<spanstyle="margin:0 10px;"></span>
<%--修改无法直接传递那么多数据 不如传个id去查再回显--%>
<a href="${pageContext.request.contextPath}/account/updateUI?id=${account.id}"
class="fa fa-edit"style="font-size:20px;color:red"></a>
</td>

</tr>
</c:forEach>
</tbody></table></div>

</body>
<!-- 引入JS文件 -->
<script type="text/javascript" src="${pageContext.request.contextPath}/js/jquery-1.9.1.js"></script>
<script type="text/javascript" src="${pageContext.request.contextPath}/js/bootstrap.min.js"></script>

</html>

AccountController.java

@Controller
@RequestMapping("/account")
public class AccountController {

@Autowired
AccountService accountService;

@RequestMapping("/findAll")
public ModelAndView findAll(){
ModelAndView modelAndView = new ModelAndView();
//添加数据
modelAndView.addObject("accountList",accountService.findAll());
//指定返回页面
modelAndView.setViewName("show");

return modelAndView;
}

@RequestMapping("/save")
public String save(Account account){
accountService.save(account);
return "redirect:findAll";//直接转到findAll方法去查询所有 多好多方便 因为不需要传数据 重定向比较好
//此处不要写forword请求转发 会导致刷新重新添加 重定向就没有这问题
//更新数据库之后一定是重定向
}

@RequestMapping("/delById")
public String delById(Integer id){
accountService.delById(id);
return "redirect:findAll";//修改了数据库最好重定向
}

@RequestMapping("/updateUI")
public ModelAndView updateUI(Integer id){
ModelAndView modelAndView = new ModelAndView();
Account account = accountService.findById(id);
modelAndView.addObject("account",account);
modelAndView.setViewName("edit");
return modelAndView;
}

@RequestMapping("/update")
public String update(Account account){
accountService.update(account);
return "redirect:findAll";
}
}

9、引入日志

pom.xml
太多 不要记 直接复制

<!--日志开始-->
<!-- 日志工具包 -->
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-api</artifactId>
<version>2.10.0</version>
</dependency>
<!--日志核心包-->
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-core</artifactId>
<version>2.10.0</version>
</dependency>
<!--web相关的功能包-->
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-web</artifactId>
<version>2.9.1</version>
</dependency>
<!--为java做简单的日志记录-->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.7.25</version>
</dependency>
<!--slf4j的log4j实现类-->
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-slf4j-impl</artifactId>
<version>2.9.1</version>
</dependency>
<!--程序运行的时候检测用了哪种日志实现类-->
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-jcl</artifactId>
<version>2.9.1</version>
</dependency>
<!--日志结束-->

log4j2.xml 注意包名与具体项目有关

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="warn" monitorInterval="30" strict="true" schema="Log4J-V2.2.xsd">
<Appenders>
<Console name="Console" target="SYSTEM_OUT">
<!-- 将日志输出到控制台 -->
<PatternLayout pattern="%date{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %level [%C{36}.%M] - %msg%n"/>
</Console>
<!--将日志输出到文件中-->
<file name="myLogFile" fileName="d:/log/ssm.log" append="true">
<PatternLayout pattern="%date{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %level [%C{36}.%M] - %msg%n"/>
</file>
</Appenders>

<Loggers>
<!-- 全局配置 -->
<root level="info">
<!--普通日志要在哪里显示-->
<appenderRef ref="Console"/>
<appender-ref ref="myLogFile"/>
</root>

<!-- 业务层日志 -->
<logger name="cn.ahpu.service" level="debug" additivity="false">
<appender-ref ref="Console"/>
<appender-ref ref="myLogFile"/>
</logger>

<!-- 持久层日志 -->
<logger name="cn.ahpu.dao" level="debug" additivity="false">
<appender-ref ref="Console"/>
<appender-ref ref="myLogFile"/>
</logger>

<!-- 事务日志 -->
<logger name="org.springframework.jdbc" level="debug" additivity="false">
<appender-ref ref="Console"/>
<appender-ref ref="myLogFile"/>
</logger>
</Loggers>


</Configuration>

log4j2拿来直接可以用 log4j1 的话必须在sqlMapConfig.xml里再配置一个打印sql语句才能有输出

log4j2.xml复制过来直接能用

springmvc_day03_ssm三大框架整合_拦截器_sql_09

三、拦截器

1、拦截器的作用

a. 拦截器类似于Servlet开发中的过滤器Filter,用于对处理器进行预处理和后处理。
b. 拦截器链(Interceptor Chain)。拦截器链就是将拦截器按一定的顺序联结成一条链。在访问被拦截的方法或字段
时,拦截器链中的拦截器就会按其之前定义的顺序被调用。
c. 拦截器,过滤器,监听器的区别
过滤器:是servlet的一部分,任何web项目都可以使用
配置 /* 后会过滤所有的资源(请求)
拦截器:是springMVC的一部分,只能在springMVC中使用
配置了/* 只会拦截请求,不会拦截静态资源
监听器:Web监听器是Servlet规范中的一种特殊类,用于监听ServletContext、HttpSession和
ServletRequest等域对象的创建与销毁事件,当Web应用启动时启动,当Web应用销毁时销毁。用于监听域对象的属性发
生修改的事件,可以在事件发生前、发生后做一些必要的处理
d. 底层采用的是aop的思想

2、拦截器的代码

a. 引入依赖

<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.0.2.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.0.2.RELEASE</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jsp-api</artifactId>
<version>2.0</version>
<scope>provided</scope>
</dependency>
</dependencies>

b.spring-mvc.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/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd">

<!--扫描包,创建类对象-->
<context:component-scan base-package="cn.ahpu.controller"></context:component-scan>
<!--视图解析器-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/pages/"></property>
<property name="suffix" value=".jsp"></property>
</bean>
<!--注解驱动-->
<mvc:annotation-driven></mvc:annotation-driven>
<!--静态资源全部放行-->
<mvc:default-servlet-handler></mvc:default-servlet-handler>
<!--拦截器:配置拦截器链-->
<mvc:interceptors>
<!--单个拦截器对象-->
<mvc:interceptor>
<!--拦截所有请求 /** -->
<mvc:mapping path="/**"/>
<!--指定拦截器类-->
<bean class="cn.ahpu.interceptor.MyInterceptor1"></bean>
</mvc:interceptor>
<!--第二个拦截器-->
<mvc:interceptor>
<mvc:mapping path="/**"/>
<bean class="cn.ahpu.interceptor.MyInterceptor2"></bean>
</mvc:interceptor>
</mvc:interceptors>
</beans>

c. 创建拦截器类

MyInterceptor1.java

package cn.ahpu.interceptor;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
* @author 寒面银枪
* @create 2020-04-29 9:41
*
* 创建自己的拦截器类,需要实现接口 HandlerInterceptor
* 写好之后到xml内配置一下
*/
public class MyInterceptor1 implements HandlerInterceptor {

//controller方法执行前执行
//作用:拦截所有请求 判断是否可以进行下一步
// eg:判断是否登录成功
// 登录成功,放行 return true;
// 登录失败,拦截 return false;
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
System.out.println("preHandle1");
return true;
}

/**
* preHandle放行了才可以执行
* controller方法执行后执行
* 作用:可以对返回的数据进行验证
*/

@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
System.out.println("postHandle1");
}

/**
* 执行完postHandle之后执行,preHandle必须放行
* 作用:释放资源
*/
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
System.out.println("afterCompletion1");
}
}

3、多个拦截器测试

a. preHandler: 按照拦截器的配置顺序正序执行, 如果返回的都是true,则执行控制器的方法
b. postHandler: 所有的preHandler执行完之后,返回的都是true, 按照拦截器配置顺序倒序执行
c. afterCompletion: 所有postHandler执行完之后,
d. 配置多个拦截器
<!--引入拦截器:配置拦截器链-->
<mvc:interceptors>
<!--配置单个拦截器对象-->
<mvc:interceptor>
<!--拦截所有的请求-->
<mvc:mapping path="/**"/>
<!--指定拦截器类-->
<bean class="com.itheima.interceptor.MyInterceptor2"></bean>
</mvc:interceptor>
<!--配置单个拦截器对象-->
<mvc:interceptor>
<!--拦截所有的请求-->
<mvc:mapping path="/**"/>
<!--指定拦截器类-->
<bean class="com.itheima.interceptor.MyInterceptor1"></bean>
</mvc:interceptor>
</mvc:interceptors>

4、在ssm中使用拦截器示例

a、登录页面

<%@ page isELIgnored="false" contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>登录</title>
<!-- 引入CSS样式 -->
<link rel="stylesheet" href="${pageContext.request.contextPath}/css/bootstrap.min.css">
</head>
<body>
<div class="container">
<br>
<form class="form-horizontal" role="form" action="${pageContext.request.contextPath}/login" method="post">
<div class="form-group">
<label for="username" class="col-sm-2 control-label">用户名</label>
<div class="col-sm-10">
<input type="text" class="form-control" id="username" name="username"
placeholder="请输入用户名">
</div>
</div>
<div class="form-group">
<label for="password" class="col-sm-2 control-label">密码</label>
<div class="col-sm-10">
<input type="password" class="form-control" id="password" name="password"
placeholder="请输入密码">
</div>
</div>
<div class="form-group">
<div class="col-sm-offset-2 col-sm-10 ">
<button type="submit" class="btn btn-success">登录</button>
</div>
</div></form></div>
</body>
<!-- 引入JS文件 -->
<script type="text/javascript" src="${pageContext.request.contextPath}/js/jquery-1.9.1.js"></script>
<script type="text/javascript" src="${pageContext.request.contextPath}/js/bootstrap.min.js"></script>

</html>

b、创建拦截器类 LoginInterceptor.java

/**
* @author 寒面银枪
* @create 2020-04-29 9:41
*
* 创建自己的拦截器类,需要实现接口 HandlerInterceptor
* 写好之后到xml内配置一下
*/
public class LoginInterceptor implements HandlerInterceptor {

/**登录验证
* 先判断是否是登录请求 若是 直接放行
* 若session内有登录信息,放行。否则拦截
*/
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
//获取请求路径
String requestURI = request.getRequestURI();
System.out.println(requestURI);
//判断是否是登录请求
if(requestURI.contains("login")){
return true;//直接放行
}
//判断是否登录了
if(request.getSession().getAttribute("username")!=null){
return true;
}else{
//跳转到登录页面
response.sendRedirect("/interceptor/login.jsp");
return false;
}
}
}

c、spring-mvc.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/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd">

<!--扫描包,创建类对象-->
<context:component-scan base-package="cn.ahpu.controller"></context:component-scan>
<!--视图解析器-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/pages/"></property>
<property name="suffix" value=".jsp"></property>
</bean>
<!--注解驱动-->
<mvc:annotation-driven></mvc:annotation-driven>
<!--静态资源全部放行-->
<mvc:default-servlet-handler></mvc:default-servlet-handler>
<!--拦截器:配置拦截器链-->
<mvc:interceptors>
<!--登录拦截器-->
<mvc:interceptor>
<mvc:mapping path="/**"/>
<!--有些浏览器会拦截静态资源 需要配置放行-->
<mvc:exclude-mapping path="/js/*"></mvc:exclude-mapping>
<mvc:exclude-mapping path="/css/*"></mvc:exclude-mapping>
<mvc:exclude-mapping path="/fonts/*"></mvc:exclude-mapping>
<bean class="cn.ahpu.interceptor.LoginInterceptor"></bean>
</mvc:interceptor>

</mvc:interceptors>
</beans>

四、小结

1. ssm 整合 = mybatis +spring + springMVC
spring的ioc解耦,aop面向切面编程--声明式事务管理
applicationContext.xml: 数据源,SqlSessionFactoryBean , MapperScannerConfig (创建动态代理,存入到springIOC容器中),事务管理器, 事务增强,aop(织入), 扫描包,创建对象(业务层)
spring-mvc.xml
1) 扫描包,创建对象 :Controller
2) 视图解析器
3)拦截器
4) 注解驱动
5) 静态资源方法
6) 自定义类型转换器
7)文件上传
2.


举报

相关推荐

0 条评论