spring
Spring简介
Spring是个java企业级应用的开源开发框架。Spring主要用来开发web应用是一个轻量级的控制反转(IOC)和面向切面(AOP)的容器框架。
Spring体系结构
核心容器:
Core模块
提供了框架的基本组成部分,包括TOC和依赖注入功能Beans模块
提供 BeanFactory,它是一个工厂模式的复杂实现Context模块
它是访问定义和配置的任何对象的媒介。ApplicationContext接口是其重点SpEL模块
表达式语言
Web层
web模块
提供了基本的面向web的集成功能,例如多个文件上传的功能和使用servlet监听器和初始化IOC容器web-MVC模块
包含Spring的模型-视图-控制器(MVC),实现了web应用程序websocket模块
为webSocket-based提供了支持,而且在web应用程序中提供了客户端和服务器端之间通信的两种方式Portlet模块
提供了在portlet环境中实现MVC
数据访问/集成
JDBC模块
提供了删除冗余的JDBC相关编码的JDBC抽象层ORM模块
为流行的对象关系映射API,包括JPA,JDO,Hibernate和iBatis,提供了集成层
OXM模块提供了抽象层,它支持对JAXB,Castor,XMLBeans,JiBx和Xstream 的对象/XML映射实现Transactions模块
为实现特殊接口的类及所有的POJO支持编程式和声明式事务管理JMS模块
Java消息服务,包含生产和消费的信息的功能
其他模块
AOP模块
提供了面向切面的编程实现,允许你定义方法拦截器和切入点Aspects模块
提供了与AspectJ的集成,这是一个功能强大且成熟的面向切面Messaging模块
处理来自websocket客户端的信息
Spring特征
三大特征:AOP、IOC、DI。
IOC : 控制反转
DI :依赖注入。
AOP : 面向切面编程
Spring loC/DI概述
loc(控制反转)
使用目的:降低耦合度
正向控制:若要使用某个对象,需要自己去负责对象的创建。反向控制:若要使用某个对象,只需要从 spring 容器中获取需要使用的对象,不关心对象的创建过程,也就是把创建对象的控制权反转给了spring框架。
DI的方式(依赖注入)
对象只提供普通的方法,容 权负责组件的装配,它会把符合依赖关系的对象通过属性(Javabean中的setter)或者是构造 传递给需要的对象。
Spring loc容器
I0C容器负责对象的创建、初始化等一系列工作,被创建或被管理的对象在IOC容器中统称为Bean。
常见的IoC容器实现方式包括 BeanFactory和ApplicationContext。
(1) BeanFactory: Spring内部使用的接口,不提倡开发人员使用。特点: 加载配置文件时不会创建对象,获取对象时才会创建对象。
(2) ApplicationContext: BeanFactory的子接口,提供了更多更强大的功能,一般由开发人员使用。特点: 加载配置文件时会把配置文件里的对象进行创建。
Spring框架入门案例
引入依赖到pom.xml中
<dependenctes>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>6.0.9</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>6.0.9</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>6.0.9</version>
</dependency>
<dependency>
<groupId>commons-1ogging</groupId>
<artifactId>commons-Togging</artifactId>
<version>1.2</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.2.8</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>6.0.9</version>
</dependency>
</dependencies>
第一步:创建Maven 项目
第二步:创建Java和resource文件夹
第三步:点击install安装Maven
第一种:set方法注入
创建Book类
public class Book {
private String bookName:
private double price;
public void setBookName(String bookName) {
this.bookName = bookName;
}
public void setPrice(double price) {
this.price = price;
}
public void show(string bookName,double price){
System.out.println("书名:"+bookName+" 价格:"+price);
}
}
编写applicationContext.xml
<bean id="book" class="com.wuji.Book">
<property name="bookName" value="aaa"></property>
<property name="price" value="19999.11"></property>
</bean>
</beans>
编写测试类
public class client1 {
public static void main(String[] args) {
//com.wuji.Book book=new com.wuji.Book();
//book.setBookName("aaa");
//book.setPrice(11.11);
//book.show();
ApplicationContext context=new ClassPathXmlApplicationContext;
Book book = context.getBean( "book",Book.class );
book.show();
}
}
通过控制反转交给spring容器去处理
第二种 有参构造方法注入
public class Book {
private String bookName;
private double price
public Book(string bookName,double price) {
this .bookName = bookName;
this.price = price;
}
public void show(){
System.out.printIn(bookName+":"+price) ;
}
}
<bean id="book”class="com.wuji.Book">
<constructor-arg name="bookName”value="aaa"></constructor-arg>
<constructor-arg name="price" value="199.9"></constructor-arg>
</bean>
第三种:注解注入
首先添加依赖
<bean id="cat” class="com.Cat"></bean>
<bean id="dog" class="com.Dog"></bean>
<bean id="animal" class="com.Animal"></bean><context:annotation-config></context:annotation-config>
</beans>
创建一个cat dog 以及 animal类
public class Animal {
@Autowired
private Cat cat;
@Autowired
private Dog dog;
public Cat getCat() {
return cat;
}
public Dog getDog() {
return dog;
}
}
@Autowried:在属性上面加,自动按照类型注入,不关心bean的id,只要有唯一的类型匹配就可以注入成功。无需s et方法。如果注入的bean在容器中类型不唯一时,它会把变量名作为bean的id,然后在容器中查找,找到则注入成功。如果没有找到一致的bean id则报错。
如果类型有多个,可以用@Qualifier
如
<bean id="cat1” class="com.Cat"></bean>
<bean id="cat2”class="com.Cat"></bean>
<bean id="dog1" class="com.Dog"></bean>
<bean id="dog2" class="com.Dog"></bean>
<bean id="animal" class="com.Animal"></bean><context:annotation-config></context:annotation-config>
</beans>
public class Animal {
@Autowired
@Qualifire(value = "cat1")
private Cat cat;
@Autowired
@Qualifire(value = "dog1")
private Dog dog;
public Cat getCat() {
return cat;
}
public Dog getDog() {
return dog;
}
}
@Qualifier:在自动搜索类型的基础上,再按照bean的id注入,属性value:用于指定bean的id。在给类成员注入数据时,不能独立使用,但在给方法的行参注入数据时,可以独立使用
既能按名称又能按类型来的注解?
@Resouce(name="")
@Componet 描述spring中的一个bean (使用后可以将xml中的bean去掉)
@Repository 将数据访问层 (Dao层) 的类标识为Spring中的bean
@service 将业务层 (Service层) 的类标识为Spring中的bean
@Contro11er 将控制层的类标识为Spring中的bean
spring的Bean
Bean的作用域
singleton: 单例模式: IOC容器中只会存在一个bean实例,无论多少bean引用它,始终指向相同的对象
prototype: 原型模式: IOC容器可以同时存在多个实例,当程序去获取bean时可创建出一个新的实例
request: 在一次Http请求中,容器会返回该Bean的同一实例。而对不同的Http请求则会产生新的Bean,而且该bean仅在当前Http Request内有效。
session: 在一次Http Session中,容器会返回该Bean的同一实例。而对不同的Session请求则会创建新的实例,该bean
实例仅在当前Session内有效。global Session: 在一个全局的Http Session中,容器会返回该Bean的同一个实例,仅在使用portlet context时有效。
spring的AOP
AOP的简介
(Aspect oriented Programming)中文翻译过来是 面向切面编程底层实现也是基于 动态代理 完成的。
AOP术语
连接点 (JointPoint ):有可能调用AOP的地方叫做 连接点提供一组规则 来匹配Join Point
切点 ( PointCut):
通知 (Advice ):
切面(ASPECT):
切面的工作被称之为通知。
由切点 (Pointcut)和通知 (Advice) 组成
AOP的实现方式
1.添加 SpringAOP 框架支持
2.定义切面和切点
3.定义通知
使用AOP织入,需要导入一个依赖包
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.4</version>
</dependency>
UserSerivce接口
public interface UserService {
public void add();
public void delete();
public void update();
public void select();
}
UserServicelmpl实现类
public class UserServiceImpl implements UserService {
@Override
public void add() {System.out.println(“增加了一个用户");
@Override
public void delete() {System.out.println("删除了一个用户");
@Override
public void update() {System.out.println("更新了一个用户");
@Override
public void select() {System.out.println("查询了一个用户");
}
例如,现在要在查询方法之前做一个预处理,在完成之后也做一个预处理
定义切面和切点
public class MyPointCut {
public void before(){
System.out.println("=========方法执行前 预处理=========");
}
public void after(){
System.out.println("=========方法执行后 执行完毕=========);
}
}
<bean id="userService" class="com.service.impl.UserServiceImpl"></bean>
<bean id="mypt"class="com.pointCut.MyPointCut"></bean>
<aop:config>
定义切面
<aop;aspect ref="mypt">
切点
<aop:pointcut id="point" expression="execution(voidcom.service,impl.UserServiceImpl.select())"/>
通知
<aop;before method="before" pointcut-ref="point"></aop:before>
<aop:after method-"after" pointcut-ref="point"></aop;after>
</aop:aspect></aop:config>
</beans>
AOP实现注解
在UserServicelmpl实现类 开头加上 @Service
给MyPoint添加注解
@Aspect
@Component
public class MyPointCut {
@Before("execution(void com.service.impl).select()")
public void before(){
System.out.println("=========方法执行前 预处理=========");
}
@After("execution(void com.service.impl).select()")
public void after(){
System.out.println("=========方法执行后 执行完毕=========);
}
}
测试
public class client1 {
public static void main(string[] args) {
ApplicationContext context=new ClassPathXmlApplicationContext(configlocation:"applicationContext.xml");
UserService userService = context.getBean( s: "userService", UserService.class);
System.out.printIn(userService.getClass());
userService.select();
}
}
通知类型
1 前置通知使用 @Before: 通知方法会在目标方法调用之前执行
2 后置通知使用 @After: 通知方法会在目标方法返回或者抛出异常后调用
3 返回之后通知使用 @AfterReturning: 通知方法会在目标方法返回后调用
4 抛异常后通知使用 @AfterThrowing: 通知方法会在目标方法抛出异常后调用5 环绕通知使用 @Around: 通知包裹了被通知的方法,在被通知的方法通知之前和调用之后执行自定义的行
spring整合mybits
1.引入依赖
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.2.10.RELEASE</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.3.</version>
</dependency>
2.MybatisConfig;java
public class MybatisConfig {
@Bean
public SqlSessionFactoryBean sqlSessionFactory(DataSourcedataSource){
SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
ssfb.setTypeAliasesPackage("com.itheima.domain");
ssfb.setDataSource(dataSource);
return ssfb;
}
@Bean
public MapperScannerConfigurer mapperScannerConfigurer(){
MapperScannerConfigurer msc = new MapperScannerConfigurer();
msc.setBasePackage("com.itheima.dao");
return msc;
}
}
3.测试类
public class client{
public static void main(String[] args) {
ApplicationContext ctx = newAnnotationConfigApplicationContext(SpringConfig.class);
AccountService accountService = ctx.getBean(AccountService.class);
Account ac = accountService.findById(2);
System.out.printIn(ac);
}
}
springMVC
SpringMVC概述
SpringMVC技术与Servlet技术功能等同,均属于web层开发技术
SpringMVC是一种基于Java实现MVC模型的轻量级Web框架优点
使用简单,开发便捷 (相比于Servlet)
灵活性强
SpringMVC入门案例
1.使用SpringMVC技术需要先导入SpringMVC坐标与Servlet坐标
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax,servlet-api</artifactId>
<version>3.1.</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.10.RELEASE</version>
</dependency>
2.创建SpringMVC控制器类 (等同于Servlet功能)
@Controller
public class UserController {
@RequestMapping("/save" )
@ResponseBody
public String save(){
System.out.println("user save ...");
return "{'info':'springmvc'}";
}
}
3.初始化SpringMVC环境 (同Spring环境) ,设定SpringMVC加载对应的bean
@Configuration
@ComponentScan("com.itheima.controller")
public class SpringMvcConfig {
}
4.初始化Servlet容器,加载SpringMVC环境,并设置SpringMVC技术处理的请求
public class ServletContainersInitConfig extends AbstractDispatcherServletInitializer { protected WebApplicationContext createServletApplicationContext(){
AnnotationConfigWebApplicationContext ctx = new AnnotationConfigwebApplicationContext();
ctx.register(SpringMvcConfig.class);
return ctx;
}
protected String[] getServletMappings() {
return new String[]{"/" };
}
protected WebApplicationContext createRootApplicationContext() {
return null;
}
}
UserController.java
//2.定义controller
//2.1使用@ControLler定义bean
@Controller
public class UserController {
//2.2设置当前操作的访问路径
@RequestMapping(~"/save")
//2.3设置当前操作的返回值类型
@ResponseBody
public String save(){
System.out.println("user save...");
return "{'module':'springmvc'}";
}
}
配置类
//3.创建springmvc的配置文件,加裁controLLer对应的bean
@Configuration
@ComponentScan("com.itheima.controller")
public class SpringMvcConfig {
}
U+实验一测试
.Spring IoC属性注入使用set方法注入,
< ① ② =" ③ " value="数据结构"/>
1.property 2.name 3.bookname
2. 使用有参数构造注入
< ④ ⑤ =" ⑥ " value="数据结构"/>
4.constructor-arg 5.name 6.bookname
3. 注入对象类型属性
public class UserServiceImpl1 implements IUserService {
private IUserDao userDao;
public void setUserDao(IUserDao userDao) {
this.userDao = userDao;
}
。。。。
}
<bean id="userService" class="nuc.edu.cn.dao.service.impl.UserServiceImpl">
< ⑦ ⑧ ="userDao" ⑨ ="userDao"/>
</bean>
<bean id="userDao"class="nuc.edu.cn.dao.impl.UserDaoImpl">
</bean>
7.property 8.name 9.ref
4. 注解注入属性
public class UserServiceImpl1 implements IUserService {
⑩
private IUserDao userDao;
@Override
public void saveCustom(String arg) {
。。。。
}
10.@Autowired
自动按照类型注入,不关心bean的id,只要有唯一的类型匹配就可以注入成功。无需s et方法。如果注入的bean在容器中类型不唯一时,它会把变量名作为bean的id,然后在容器中查找,找到则注入成功。如果没有找到一致的bean id则报错。
U+实验二测试
以下web应用
URL地址输入:http://localhost:8080/test/hello1
页面输出字符串“Hello Spring Boot!”
@Controller
@RequestMapping("/test")
public class HelloController {
//注解用于处理请求地址映射
① @RequestMapping("/hello1")
//响应为JSON数据集
② @ResponseBody
public String hello() {
return "Hello Spring Boot!";
}
}
以下web应用 控制类代码 调用业务层实现图书信息查询,添加。
@Controller
@RequestMapping("book")
public class UserController {
③ @Autowired
private IUserService userService;
/**
* 1.按bookId查询,查询bookId的值为“001”的图书,显示结果JSON格式
* 请写出URL地址:http://localhost:8080/ ④ book/getById?bookId=001
*/
@RequestMapping("getById")
@ResponseBody
public Book getBookById(Integer bookId) {
Book book = bookService.getBook(bookId);
return book;
}
/**
* 2. 按bookId查询,显示查询结果JSP视图中,
* jsp页面路径book/details.jsp
*/
@RequestMapping("/getByIdForJSP")
public ⑤ ModelAndView getBookById1(Integer id) {
Book book= bookService.getBook( ⑥ id );
ModelAndView mv = new ModelAndView();
mv.addObject("book1", ⑦book );
mv.setViewName("⑧ book ");
// 返回模型和视图
return ⑨ mv ;
}
/**
* 3. 按bookId查询,查询bookId为"003"的图书信息
* 请写出URL地址:http://localhost:8080/ ⑩ book/getBookById/003
*/
@GetMapping("/getBookById/{id}")
@ResponseBody
public User get( ⑾ @PathVariable Integer id) {
return bookService.getBook( ⑿ id );
}
/**
* 4.如果获取图书编号为“bookId3“且图书名称为”bookName3”的图书信息,查询结果为多条数据
* 请写出URL地址:
* http://localhost:8080/ ⒀ book/list/bookId3/bookName3
*/
@RequestMapping("list/{bookId1}/{bookName1}")
@ResponseBody
public List<Book> list1( ⒁ @PathVariable("bookId1") String bookId, ⒂@PathVariable("bookName1") String bookName) {
⒃ Book> books = BookService.findBooks(bookId, bookName);
return books;
}
/**
* 5. 使用@RequestParam获取参数,按bookId与bookName查询信息
* 如果bookId参数必须填写,bookName参数可填可不填
* /
@RequestMapping("list2")
@ResponseBody
Public Book list2(
@RequestParam(value="bookId", ⒄ required=true ) String bookId,
@RequestParam(value="bookName", 18required=false ) String bookName) {
Book book= userService.findBook(bookId, bookName);
return book;
}
/**
* 6 .打开“新增图书”请求页面, 页面显示用户信息文本框 return 字符串,指向页面
* URL地址:http://localhost:8080/⒆ book/add
*/
@RequestMapping("add")
public String add( ) {
return "/book/add";
}
/**
* 7. 新增图书
*前端将数据转换为JSON数据后,通过HTTP请求体提交给后端。
*/
@PostMapping("/insert")
@ResponseBody
public User insert(⒇ @RequestBody Book book) {
bookService.insertBook(book);
return user;
}
}
U+实验四测试
一、test数据库中t_user表结构如下:
1) 定义实体类
package com.cn.entity
public class User {
private Integer id;
private String userName;
private String note;
setter 、getter方法
}
2)持久层
package com.cn.dao;
/***import***/
① @Mapper
public interface IUserDao {
public List<User> findAllUsers();
public User getUserById(Integer uid);
public Integer insertUser(User user);
。。。
}
3) UserMapper.xml文件
<mapper namespace=" ② com.cn.dao.IUserDao ">
<select id=" ③ getUserById " parameterType="Integer" resultType=" ④ com.cn.entity.User ">
select id,user_name as userName,note from t_user where id= ⑤ #{id}
</select>
<select id=" ⑥ findAllUsers " resultType=" ⑦com.cn.entity.User ">
select id,user_name as userName,note from t_user
</select>
<insert id="⑧ insertUser " parameterType=" ⑨ com.cn.entity.User " ⑩ useGeneratedKeys ="true" keyProperty="id">
insert into t_user(user_name,note) values(#{userName},#{note})
</insert>
</mapper>
U+实验五测试
补充完整代码:
部门表和员工表结构如下:(一个部门有多名员工,一名员工只能属于一个部门,两表通过部门编号deptno建立连接)
1. 定义实体类
package com.cn. pojo
//员工实体类
public class Emp {
private Integer empno;
private String ename;
…..
private (1) Dept dept; //定义员工和部门的关系 dept为成员变量
setter,getter 方法
}
package com.cn. pojo
//员工部门实体类
public class Dept {
private Integer deptno;
private String dname;
private String location;
private (2) List< emps; //定义部门和员工的关系,emps为成员变量
setter,getter 方法
}
2. Dao 接口
package com.cn.dao;
…
public interface IEmpDao {
public Emp findByEmpno(Integer empno); //按员工编号查询员工信息及员工所属部门信息
public List<Emp> findByDeptno(Integer deptno); //根据部分编号查询员工信息
}
3. EmpMapper.xml文件
<mapper namespace=" com.cn.dao.IEmpDao ">
<!—手动映射 Dept表和Java Dept类属性 -->
< (3)resultMap id="empMap" type=" (4) com.cn.pojo.Emp ">
< (5) id property="empno" column="empno"/>
< (6) result property="ename" column="ename"/>
。。。。。
< (7) association property="dept" javaType=" (8) com.cn.pojo.Dept ">
。。。。。
</ (7) >
</ (3) >
<!--根据empno查询员工,关联Dept表 -->
<select id=" (9)findByEmpno " parameterType="Integer" resultMap=" (10)empMap ">
select * from emp e,dept d
where e.deptno=d.deptno and e.empno=#{empno}
</select>
<!--根据deptno查询员工-->
<select …….>
select * from emp where deptno=#{deptno}
</select>
</mapper>
4. Dao 接口
package com.cn.dao;
…
public interface IDeptDao {
public Dept findByDeptno(Integer deptno);//按部门编号查询员工信息,包括员工详细信息
}
5. DeptMapper.xml文件
<mapper namespace="com.cn..dao.IDeptDao">
<resultMap type=" (11)com.cn.pojo.Dept" id="deptMap">
< (12)id property="deptno" column="deptno"/>
< (13) result property="dname" column="dname"/>
。。。
< (14) collection property=" (15)emps " javaType=" (16)ArrayList " ofType=" (17) com.cn.pojo.Emp " column="deptno" select=" (18)com.cn.dao.IEmpDao.findByDeptno ">
</ (14) >
</ resultMap>
<!--根据部门编号查询员工 -->
<select id=" (19)findByDeptno" parameterType="Integer" resultMap=" (20)deptMap ">
select * from dept where deptno=#{deptno}
</select>
</mapper>
Spring MVC阶段测试
以下代码清单为控制器类实现,启动Spring Boot应用后,在浏览器中输入请求URL:http://localhost:8080/user1/1,运行结果如图所示。
请补充完整代码。(注意:输入答案时区分大小写,标点符号为英文状态下输入。)
@GetMapping("(1) ")
//响应为JSON数据集
(2)
public User get((3) Integer id) {
return userService.getUser(id);
}
1、
/user1/{id} user1/{id}
2、
@ResponseBody
3、
@PathVariable("id")
以下代码清单实现单文件上传,运行结果如图所示,请补充完整代码。(注意:输入答案时区分大小写,标点符号为英文状态下输入。)
URL地址栏输入 http://localhost:8080/upload/page
图1 文件上传页面
图2 选择文件
图3 文件上传结果
1)上传文件JSP /WEB-INF/jsp/file/upload.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<html>
<body>
<form method="(1) "
action="/upload /multipart" enctype="(2) ">
<input type="file" name="photo" value="请选择上传的文件" />
<input type="submit" value="提交" />
</form>
</body>
</html>
1.post
2、multipart/form-data
2)文件上传控制器
package com.springmvc.chapter0320191007.controller;
(3)
public class FileController {
(4)
public (5) Map<String, Object> upload((6) ("photo") (7) photo)
{
String path = "d:/uploaded/";//保存路径
String filename = new SimpleDateFormat("yyyyMMddHHmmssSSS").format(new Date());
3、@Controller
4、@PostMapping("/upload/multipart")
5、@ResponseBody
6、@RequestParam
7、MultipartFile
//获取上传文件的后缀suffix
String suffix = photo.getOriginalFilename().substring(photo.getOriginalFilename().lastIndexOf("."));
try {
//Spring提供了文件操作类FileCopyUtils
FileCopyUtils.copy(photo.getInputStream(), new FileOutputStream(path + filename + suffix));
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
return (8) (false, "上传失败");
}
return (9) (true, "上传成功");
}
// 处理上传文件结果
private Map<String, Object> dealResultMap(boolean success, String msg) {
Map<String, Object> result = new HashMap<String, Object>();
result.put("success", success);
result.put("msg", msg);
return (10) ;
}
}
8、dealResultMap
9、dealResultMap
10、result
以下代码清单为拦截器的使用,请补充完整代码。(注意:输入答案时区分大小写,标点符号为英文状态下输入。)
// 自定义简单拦截器Interceptor1
public class Interceptor1 implements (1) {
@Override
public boolean (2) (HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {
// TODO Auto-generated method stub
System.out.println("处理器前方法");
// 返回true,不会拦截后续的处理
return true;
}
@Override
public void (3) (HttpServletRequest request, HttpServletResponse response, Object handler,
ModelAndView modelAndView) throws Exception {
// TODO Auto-generated method stub
System.out.println("处理器后方法");
}
@Override
public void (4) (HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
throws Exception {
// TODO Auto-generated method stub
System.out.println("处理器完成方法");
}
}
1、HandlerInterceptor
2、preHandle
3、postHandle
4、afterCompletion
//注册拦截器
@Configuration
@SpringBootApplication(scanBasePackages="com.springmvc.chapter0320191007")
public class App1 implements WebMvcConfigurer {
public static void main(String[] args) {
// TODO Auto-generated method stub
SpringApplication.run(App1.class, args);
}
@Override
public void (5) (InterceptorRegistry registry) {
// TODO Auto-generated method stub
InterceptorRegistration ir=registry.addInterceptor((6) );
// 拦截interceptor路径下所有请求
ir.addPathPatterns("(7) ");
}
}
5、addInterceptors
6、new Interceptor1( ) new Interceptor1()
7、/interceptor/*
1) 静态页面index.html 核心代码:
<html xmlns:th="http://www.thymeleaf.org">
<head>
。。。。。
<script type="text/javascript">
$(function(){
$("#loginbtn").click(function(){
var loginName = $("#loginName");
var password = $("#password");
var msg = "";
if(loginName.val() == ""){
msg = "登录名不能为空!";
loginName.focus();
}else if(password.val() == ""){
msg = "密码不能为空!";
password.focus();
}
if(msg != ""){
alert(msg);
}else{
$("#loginform").submit();
}
})
})
</script>
</head>
<body>
<h2>用户登录</h2>
<form action="login" method="post" id="loginform">
<input type="text" name="loginName" id="loginName" />
<input type="password" name="password" id="password" />
<button type="button" id="loginbtn"> 登录</button>
<button type="button" id="registerbtn"> 注册</button>
</body>
</html>
2) 通过控制类访问index.html
package nuc.edu.cn.chapter03.controller;
/***Import***/
(1)
public class IndexController {
//Spring MVC会自动生成视图,并且绑定数据模型
public String index(Model model) {
System.out.println("IndexController index方法被调用。。。。");
return "index";
}
}
3)处理请求的控制类LoginController
package nuc.edu.cn.chapter03.controller;
/***Import***/
(2)
public class LoginController {
@PostMapping("(3) ")
public ModelAndView login( (4) String loginName, (5) String password,ModelAndView mv) {
System.out.println("LoginController login方法被调用。。。");
System.out.println("LoginController 登录名 :"+loginName+" 密码:"+password);
mv.setViewName("redirect:/main");
return mv;
}
}
4)处理请求的控制类 MainController
package nuc.edu.cn.chapter03.controller;
/***Import***/
@Controller
public class MainController {
@RequestMapping(" (6) ")
public String main() {
System.out.println("MainController main方法被调用。。。");
//根据Thymeleaf默认模板,将返回resources/templates/main.html
return "main";
}
}
5)静态页面main.html 核心代码:
<html xmlns:th="http://www.thymeleaf.org">
<head>
。。。。
</head>
<body>
<a th:href=" #">测试表达式访问数据</a><br/>
<a th:href=" #">测试条件判断</a><br/>
<a th:href=" #">测试循环</a><br/>
</body>
</html>
1、
@Controller
2、
@Controller
3、
/login login
4、
@RequestParam("loginName")
5、
@RequestParam("password")
6、
/main main