SpringMVC
SSM:mybatis +Spring +SpringMVC MVC三层架构
JavaSE:认真学习,看视频老师带,入门快
JavaWeb:认真学习,看视频老师带,入门快
SSM框架:研究官方文档,锻炼自学能力,锻炼笔记能力,锻炼项目能力
SpringMVC + Vue +SpringBoot +SpringCloud + Linux
SSM=javaWeb做项目;
Spring: IOC 和 AOP
SpringMVC:SpringMVC的执行流程
SpringMVC:SSM框架整合!
Spring
MVC:模型(dao,service) 视图(view) 控制器(Controller)
dao
service
servlet:转发、重定向
jsp/html
前端 数据传输 实体类
实体类:用户名,密码,生日,爱好,。。。。20个
前端:用户名,密码
pojo:User
vo:UserVo (细化,只存放自己需要的东西)
dto:
JSP:本质是一个Servlet
假设:你的项目的架构,是设计好的,还是演进的?
肯定是演进的
- Alibaba PHP
- 随着用户量大, Java
- 王坚 去IOE MySQL
- MySQL: MySQL—>AliSQL、AliRedis
- All in One —> 微服务
MVC:
MVVM: M V VM ViewModel:双向绑定
什么是SpringMVC?
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fyaRtd67-1624776864764)(SpringMVC.assets/image-20210622003758209.png)]
我们为什么要学习SpringMVC呢?
- 轻量级,简单易学
- 高效,基于请求响应的MVC框架
- 与Spring兼容性好,无缝结合
- 约定优于配置
- 功能强大:RESTful、数据验证,格式化,本地化,主题等
- 简单灵活
中心控制器
Spring的web框架围绕DispatcherServlet设计。DisPatcherServlet的作用将请求分发到不同的处理器。从Spring2.5开始,使用Java5或者以上版本的用户可以采用基于注解的controller声明方式。
Spring MVC框架就像许多其他MVC框架一样,以请求为驱动,围绕一个中心Servlet分派请求及提供其他功能,DisPatcherServlet是一个实际的Servlet(它继承自HttpServlet基类)。
SpringMVC的原理如下图所示:
当发起请求时被前置的控制器拦截到请求,根据请求参数生成代理请求,找到请求对应的实际控制器,控制器处理请求,创建数据模型,访问数据库,将模型响应给中心控制器,控制器使用模型与视图渲染视图的结果,将结果返回给中心控制器,再将结果返回给请求者。
HelloSpringMVC
配置版
- 新建一个Moudle,添加web的支持!
- 确定导入了SpringMVC的依赖!
- 配置web.xml,注册DispatcherServlet
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0">
<!--1.注册DispatcherServlet-->
<servlet>
<servlet-name>springmvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!--关联一个springmvc的配置文件:【servlet-name】-servlet.xml-->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc-servlet.xml</param-value>
</init-param>
<!--启动级别-1-->
<load-on-startup>1</load-on-startup>
</servlet>
<!--/匹配所有的请求:(不包括.jsp)-->
<!--/*匹配所有的请求:(包括.jsp)-->
<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
- 编写SpringMVC的配置文件!名称:springmvc-servlet.xml:[servletname]-servlet.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:util="http://www.springframework.org/schema/util"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/util https://www.springframework.org/schema/util/spring-util.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
</beans>
- 添加处理映射器
<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
- 添加处理器适配器
<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>
- 添加视图解析器
<!--视图解析器:DispatcherServlet给他的ModelAndView-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
<!--前缀-->
<property name="prefix" value="/WEB-INF/jsp/"/>
<!--后缀-->
<property name="suffix" value=".jsp"/>
</bean>
- 编写我们要操作业务Controller,要么实现Controller接口,要么增加注解;需要返回一个ModelAndView,装数据,封视图
package com.ljh.servlet;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class HelloController implements Controller {
public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
//ModeLAndView模型和视图
ModelAndView mv = new ModelAndView();
//封装对象,放在ModelAndView中,Model
mv.addObject("msg","HelloSpringMVC!");
//封装要跳转的视图,放在ModelAndView中
mv.setViewName("hello");//:/WEB-INF/jsp/hello.jsp
return mv;
}
}
- 将自己的类交给SpringIOC容器,注册bean
<!--Handler-->
<bean id="/hello" class="com.ljh.servlet.HelloController"/>
- 写要跳转的jsp页面,现实ModelAndView存放的数据,以及我们的正常页面;
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
${msg}
</body>
</html>
11.配置Tomcat启动测试!
可能遇到的问题:访问出现404,排查步骤:
- 查看控制台输出,看以下是不是缺少什么jar包。
- 如果jar包存在,现实无法输出就在IDEA的项目发布中,添加lib依赖!
操作步骤:
点击file,进入Project Settings–>Artifacts
打开文件夹路径新建lib文件夹
3. 重启Tomcat即可解决!
小结:看到这个估计很多朋友都能理解其中的原理了,但是我们实际开发中才不会这么写,不然就疯了,还学这个玩意干嘛!我们来看个注解版实现,这才是SpringMVC的精髓,到底有多么简单?
注解版
**第一步:新建一个Moudle,添加web支持!**建立包结构com.ljh.controller
第二步:由于Maven可能存在资源过滤的问题,我们将配置完善
<build>
<resources>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>false</filtering>
</resource>
<resource>
<directory>src/main/resources</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>false</filtering>
</resource>
</resources>
</build>
第三步:在pom.xml文件引入相关的依赖:
主要有Spring框架核心库、Spring MVC、servlet、JSTL等。我们在父依赖中已经引入了!
第四步:配置web.xml
注意点:
- 注意web.xml版本问题,要最新版!目前4.0
- 注册DispatcherServlet
- 关联SpringMVC的配置文件
- 启动级别为1
- 映射路径为/【不要用/*,会404】
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0">
<servlet>
<servlet-name>springmvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc-servlert.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
第五步:添加Spring MVC 配置文件
- 让IOC的注解生效
- 静态资源过滤:HTML、JS、CSS、图片、视频…
- MVC的注解驱动
- 配置视图解析器
在resource目录下添加springmvc-servlet.xml配置文件,配置的形式与Spring容器配置基本类似,为了支持基于注解的IOC,设置了自动扫描包的功能,具体配置信息如下:
<?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/mvc
http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.2.xsd">
<!--自动扫描包,让指定包下的注解生效,由IOC容器统一管理-->
<context:component-scan base-package="com.ljh.controller"/>
<mvc:default-servlet-handler/>
<mvc:annotation-driven/>
<!--视图解析器:DispatcherServlet给他的ModelAndView
1.获取了ModelAndView的数据
2.解析ModelAndView的视图名字
3.拼接视图名字,找到对应的视图 /WEB-INF/jsp/hello.jsp
4.将数据渲染到这个视图上
-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
<!--前缀-->
<property name="prefix" value="/WEB-INF/jsp/"/>
<!--后缀-->
<property name="suffix" value=".jsp"/>
</bean>
</beans>
在视图解析器中我们把所有的视图都存放在/WEB-INF/目录下,这样可以保证视图安全,因为这个目录下的文件,客户端不能直接访问。
第六步:创建Controller
编写一个Java控制类com.ljh.controller.HelloController,注意编码规范
package com.ljh.controller;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public class HelloController{
@RequestMapping("/h1")
public String hello(Model model){
//封装数据
model.addAttribute("msg","注解");
return "hello";//会被视图解析器处理
}
}
第七步:
在WEB-INF/jsp目录中创建hello.jsp,视图可以直接取出并展示从Controller带回的信息;
可以通过EL表示取出Model中存放的值,或者对象:
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
${msg}
</body>
</html>
第八步:配置Tomcat运行
配置Tomcat,开启服务器,访问对应的请求路径
ok,运行成功!
小结
实现步骤其实非常的简单:
- 新建一个web项目
- 导入相关jar包
- 编写web.xml,注册DispatcherServlet
- 编写springmvc配置文件
- 接下来就是去创建对应的控制类,controller
- 最后完善前端视图和controller之间的对应
- 测试运行调试
使用springMVC必须配置的三大件:
处理器映射器、处理器适配器、视图解析器
通常,我们只需要手动配置视图解析器,而处理器映射器和处理器适配器只需要开启注解驱动即可,而省去了大段的xml配置
SpringMVC执行原理
图为SpringMVC的一个较完整的流程图,实线表示SpringMVC框架提供的技术,不需要开发者实现,虚线表示需要开发者实现。
简单分析执行流程
1.DispatcherServlet表示前置控制器,是整个SpringMVC的控制中心,用户发出请求,DispatcherServlet接收请求并拦截请求。
- 我们假设请求的url为:http://localhost:8080/SpringMVC/hello
- 如上url拆分成三部分:
- http://localhost:8080服务器域名
- SpringMVC部署在服务器上的web站点
- hello表示控制器
- 通过分析,如上url表示为请求位于服务器localhost:8080上的SpringMVC站点的hello控制器。
- HandlerMapping为处理器映射,DispatcherServlet调用
HandlerMapping,HandlerMapping根据请求url查找Handler.
- HandlerExecution表示具体的Handler,其主要作用是根据url查找控制器,如url被查找控制器为:hello。
- HandlerExecution将解析后的信息传递给DispatcheServlet,如解析控制器映射等。
- HandlerAdapter表示处理器适配器,其按照特定的规则去执行Handler。
- Handler让具体的Controller执行。
- Controller将具体的执行信息返回给HandlerAdapter,如ModelAndView。
- HandlerAdapter将视图逻辑名或模型传递给DispatcherServlet。
- DispatcherServlet调用视图解析器(ViewResolver)来解析HandlerAdapter传递的逻辑视图名。
- 视图解析器将解析的逻辑视图名传给DispatcherServlet。
- DispatcherServlet根据视图解析器解析的视图结果,调用具体的视图。
- 最终视图呈现给用户。
在这里先听一边原理,不理解没有关系,我们马上来写一个对应的代码实现,如果不明白就写10遍,没有笨人,只有懒人。
SpringMVC:Controller及RestFul风格
控制器Controller
- 控制器复杂提供访问应用程序的行为,通常通过接口定义或注解定义两种方法实现。
- 控制器负责解析用户的请求并将其转换为一个模型。
- 在Spring MVC中一个控制器类可以包含多个方法
- 在Spring MVC中,对于Controller的配置方式有很多中
我们来看看有哪些方式可以实现:
实现Controller接口
Controller是一个接口,在org.springframework.web.servlet.mvc包下,接口中只有一个方法:
//实现该接口的类获得控制器功能
public interface Controller {
//处理请求且返回一个模型与视图对象
ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception;
}
测试
- 新建一个Moudle,springmvc04,将03靠背一份进行操作!
- 删除HelloController
- mvc的配置文件只留下视图解析器!
- 编写一个Controller类,HelloController
package com.ljh.controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class HelloController implements Controller {
public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
ModelAndView modelAndView = new ModelAndView();
modelAndView.addObject("msg","controller");
modelAndView.setViewName("hello");
return modelAndView;
}
}
- 编写完毕后,去Spring配置文件中注册请求的bean;name对应请求路径,class对应处理请求的类
<bean id="/h2" class="com.ljh.controller.HelloController"/>
- 编写前端hello.jsp,注意WEB-INF/jsp目录下编写,对应我们的视图解析器
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
${msg}
</body>
</html>
5、配置Tomcat运行测试,我这里没有项目发布名配置的就是一个/,所以请求不用加项目名,OK!
说明:
- 实现接口Controller定义控制器是较老的办法
- 缺点是:一个控制器中只有一个方法,如果要多个方法则需要定义多个Controller;定义的方式比较麻烦;
使用注解@Controller
-
@Controller注解类型用于声明Spring类的实例是一个控制器(在讲IOC时还提到了另外三个注解)
-
Spring可以使用扫描机制来找到应用程序中所有基于注解的控制器类,为了保证Spring能找到你的控制器,需要在配置文件中声明组件扫描
<!--自动扫描包,让指定包下的注解生效,由IOC容器统一管理-->
<context:component-scan base-package="com.ljh.controller"/>
- 增加一个HelloController2类,睡衣弄个注解实现
package com.ljh.controller;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public class HelloController2 {
@RequestMapping("/h2")
public String hello(Model model){
//封装数据
model.addAttribute("msg","注解");
return "hello";//会被视图解析器处理
}
}
运行tomcat测试
可以发现,我们的两个请求都可以指向一个视图,但是页面结果的结果是不一样的,从这里可以看出视图是被复用的,而控制器与视图之间是弱耦合关系。
RequestMapping
@RequestMapping
- @RequestMapping注解用于映射url到控制器类或一个特定的处理程序方法。可用于类或方法上,用于类上,表示类中的所有响应请求的方法都是以该地址作为父路径。
- 为了测试结论更加准确,我们可以加上一个项目测试
- 只注解在方法上面
@Controller
public class HelloController2 {
@RequestMapping("/h2")
public String hello(Model model){
//封装数据
model.addAttribute("msg","注解");
return "hello";//会被视图解析器处理
}
}
访问路径:http://localhost:8080/项目名/h2
- 同时注解类与方法
@Controller
@RequestMapping("/c3")
public class HelloController3 {
@RequestMapping("/t1")
public String test(Model model){
model.addAttribute("msg","requestMapping");
return "hello";
}
}
访问路径:http://localhost:8080/项目名/c3/h2,需要先指定类的路径再指定方法的路径;
RestFul风格
概念
Restful就是资源定位及资源操作的风格,不是标准的也不是协议,只是一种风格。基于这个风格设计的软件可以更简洁,更有层次,更易于实现缓存等机制。
功能
- 资源:互联网所有的事物都可以抽象为资源
- 资源操作:使用POST、DELETE、PUT、GET,使用不同方法对资源进行操作
- 分别对应 添加、删除、修改、查询。
**传统方式操作资源:**通过不同的参数来实现不同的效果!方法单一,post和get
**使用RESTful操作资源:**可以通过不同的请求方式来实现不同的效果!如下:请求地址一样,但是功能可以不同!
学习测试
- 再新建一个类RestFulController
@Controller
public class RestFulController {
}
- 在Spring MVC中可以使用@PathVariable注解,让方法参数的值对应绑定到一个URI模板变量上。
@Controller
public class RestFulController {
//原来的:http://localhost:8080/add?a=1&b=2
@RequestMapping("/add")
public String test(int a, int b, Model model){
int res = a + b;
model.addAttribute("msg","结果为"+res);
return "hello";
}
//RestFul:http://localhost:8080/add/1/2
//映射访问路径
@RequestMapping("/add/{a}/{b}")
public String test2(@PathVariable int a, @PathVariable int b, Model model){
int res = a + b;
model.addAttribute("msg","结果为"+res);
return "hello";
}
}
- 我们测试请求查看下
思考:使用路径变量的好处?
- 使路径变得更加简洁;
- 获得参数更加方便,框架会自动进行类型转换
- 通过路径变量的类型可以榆树访问参数,如果类型不一样,则访问不到对应的请求方法,如这里访问的路径是/add/1/a,则路径与方法不匹配,而不会是参数转换失败
正常代码为,传参匹配
@RequestMapping("/add/{a}/{b}")
public String test3(@PathVariable int a, @PathVariable String b, Model model){
String res = b+a;
model.addAttribute("msg","结果为"+res);
return "hello";
}
使用method属性指定请求类型
用于约束请求的类型,可以收窄请求范围。指定请求谓词的类型如GET,POST,HEAD,OPTIONS,PUT,PATCH,DELETE,TRACE等
我们来测试一下:
- 增加一个方法
@RequestMapping(value="/hello",method = RequestMethod.POST)
public String test4(Model model){
model.addAttribute("msg","测试方法");
return "hello";
}
- 我们使用浏览器地址栏进行访问默认是Get请求,会报错405;
- 改成GET就正常了
@RequestMapping(value="/hello",method = RequestMethod.GET)
public String test4(Model model){
model.addAttribute("msg","测试方法");
return "hello";
}
小结:
Spring MVC的@RequestMapping注解能够处理HTTP请求的方法,比如GET,PUT,POST,DELETE一级PATCH。
所有的地址栏请求默认都会是HTTP GET类型的。
方法级别的注解变体有如下几个:组合注解
@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping
@GetMapping是一个组合注解
它所扮演的是@RequestMapping(method = RequestMethod.GET)的一个快捷方式。
平时使用的会比较多!
@GetMapping("/hello")
public String test4(Model model){
model.addAttribute("msg","测试方法");
return "hello";
}
测试post
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<form action="/add/1/b" method="post">
<input type="submit">
</form>
</body>
</html>
@PostMapping("/add/{a}/{b}")
public String test5(@PathVariable int a, @PathVariable String b, Model model){
String res = b+a;
model.addAttribute("msg","结果为"+res);
return "hello";
}
结果
结果跳转方式
ModelAndView
设置ModelAndView对象,根据view的名称,和视图解析器跳到指定的页面。
页面:{视图解析器前缀}+viewName + {视图解析器后缀}
<!--视图解析器:DispatcherServlet给他的ModelAndView
1.获取了ModelAndView的数据
2.解析ModelAndView的视图名字
3.拼接视图名字,找到对应的视图 /WEB-INF/jsp/hello.jsp
4.将数据渲染到这个视图上
-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
<!--前缀-->
<property name="prefix" value="/WEB-INF/jsp/"/>
<!--后缀-->
<property name="suffix" value=".jsp"/>
</bean>
对应的controller类
public class HelloController implements Controller {
public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
ModelAndView modelAndView = new ModelAndView();
modelAndView.addObject("msg","controller");
modelAndView.setViewName("hello");
return modelAndView;
}
}
ServletAPI
通过设置ServletAPI,不需要试图解析器
- 通过HttpServletResponse进行输出
- 通过HttpServletResponse实现重定向
- 通过HttpServletResponse实现转发
package com.ljh.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
@Controller
public class ResultGo {
@RequestMapping("/m1/t1")
public String test(HttpServletRequest request, HttpServletResponse response){
HttpSession session = request.getSession();
System.out.println(session.getId());
return "hello";
}
@RequestMapping("/m1/t2")
public void test2(HttpServletRequest request, HttpServletResponse response) throws IOException {
response.getWriter().println("fkdalaslf");
}
@RequestMapping("/m1/t3")
public void test3(HttpServletRequest request, HttpServletResponse response) throws IOException {
response.sendRedirect("/a.jsp");
}
@RequestMapping("/m1/t4")
public void test4(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
response.sendRedirect("/a.jsp");
request.setAttribute("msg","/dfad");
request.getRequestDispatcher("/WEB-INF/jsp/hello.jsp").forward(request,response);
}
}
SpringMVC
通过SpringMVC来实现转发和重定向-无需视图解析器;
测试前,需要将视图解析器注释掉
package com.ljh.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public class ResultSpringMVC {
@RequestMapping("/rsm/t1")
public String test1(){
//转发
return "/index.jsp";
}
@RequestMapping("/rsm/t2")
public String test2(){
//转发二
return "forward:/WEB-INF/jsp/test.jsp";
}
@RequestMapping("/rsm/t3")
public String test3(){
//重定向
return "redirect:/index.jsp";
}
}
通过SpringMVC来实现转发和重定向-需要视图解析器;
重定向,不需要视图解析器,本质就是重新请求一个新地方嘛,所以注意路径问题。
可以重定向到另外一个请求实现。
package com.ljh.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public class ResultSpringMVC2 {
@RequestMapping("/rsm2/t1")
public String test1(){
//转发
return "hello";
}
@RequestMapping("/rsm2/t3")
public String test3(){
//重定向
return "redirect:/index.jsp";
}
}
SpringMVC:数据处理
处理提交数据
- 提交的域名称和处理方法的参数名一致
提交数据:http://localhost:8080/add?a=1&b=3
处理方法:
@RequestMapping("/add")
public String test(int a, int b, Model model){
int res = a + b;
model.addAttribute("msg","结果为"+res);
return "hello";
}
- 提交的域名称和处理方法的参数名不一致
提交数据:http://localhost:8080/add?aa=1&b=3
@RequestMapping("/add")
public String test(@RequestParam("aa") int a, int b, Model model){
int res = a + b;
model.addAttribute("msg","结果为"+res);
return "hello";
}
3. 提交的是一个对象
要求提交的表单域和对象的属性名一致,参数使用对象即可
- 实体类
package com.ljh.pojo;
public class User {
private int id;
private String name;
private int age;
public User() {
}
public User(int id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
'}';
}
}
- 提交数据:http://localhost:8080/user?name=ab&id=3&age=1
- 处理方法:
@RequestMapping("/user")
public String test4(User user){
System.out.println(user);
//重定向
return "hello";
}
后台输出:User{id=3, name=‘ab’, age=1}
说明:如果使用对象的化,前端传递的参数名和对象名必须一直,否则就是null。
数据显示到前端
第一种:通过ModelAndView
前面一直都是如此,就不过多解释
public class HelloController implements Controller {
public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
ModelAndView modelAndView = new ModelAndView();
modelAndView.addObject("msg","controller");
modelAndView.setViewName("hello");
return modelAndView;
}
}
第二种:通过ModelMap
ModelMap
@GetMapping("/t2")
public String test2(String name, ModelMap modelMap){
//1.接收前端参数
System.out.println("接收前端的参数为:"+name);
//2.将返回的结果传递给前端,Model
modelMap.addAttribute("msg",name);
//3.视图跳转
return "test";
}
第三种:通过Model
Model
@GetMapping("/t1")
public String test(String name, Model model){
//1.接收前端参数
System.out.println("接收前端的参数为:"+name);
//2.将返回的结果传递给前端,Model
model.addAttribute("msg",name);
//3.视图跳转
return "test";
}
对比
就对于新手而言简单来说使用的区别就是:
Model 只有寥寥几个方法只适合用于储存数据,建华了新手对于Model对象的操作和理解
ModelMap 继承了LinkedMap,除了实现了自身的一些方法,同样的继承LinkedMap的方法和特性
ModelAndView 可以在储存数据的同时,可以进行设置返回的逻辑视图,进行控制展示层的跳转
当然更多的以后开发考虑的更多的是性能和优化,就不能单单仅限于此的了解。
使用80%的时间大号扎实的基础,剩下18%的时间研究框架,2%的时间去学点英文,框架的官方文档永远是最好的教程。
乱码问题
测试步骤
- form.jsp
<form action="/e/t1" method="get">
<input type="text" name="name">
<input type="submit">
</form>
- java代码
package com.ljh.controller;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public class EncodingController {
//过滤器解决乱码
@GetMapping("/e/t1")
public String test1(String name, Model model){
model.addAttribute("msg",name);
return "test";
}
}
- 输入中文测试,发现乱码
不得不说,乱码问题是我们开发中十分常见的问题,也是让我们程序员比较头大的问题!
以前乱码问题通过过滤器解决,
package com.ljh.filter;
import javax.servlet.*;
import java.io.IOException;
public class EncodingFilter implements Filter {
public void init(FilterConfig filterConfig) throws ServletException {
}
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
request.setCharacterEncoding("utf-8");
response.setCharacterEncoding("utf-8");
chain.doFilter(request,response);
}
public void destroy() {
}
}
web.xml增加内容
<filter>
<filter-name>encoding</filter-name>
<filter-class>com.ljh.filter.EncodingFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>encoding</filter-name>
<url-pattern>/</url-pattern>
</filter-mapping>
而SpringMVC给我们提供了一个过滤器,可以在web.xml中配置,修改了xml文件需要重启服务器!
<filter>
<filter-name>encoding</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>encoding</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
表单form的post请求依然乱码,请改tomcat的配置
有些极端情况下,这个过滤器对get的支持不好。
处理方法:
- 修改tomcat配置文件:设置编码!
<Connector port="8080" URIEncoding="utf-8" protocol="HTTP/1.1"
connectionTimeout="20000"
redirectPort="8443" />
- 自定义过滤器
package com.ljh.filter;
import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Map;
public class GenericEncodingFilter implements Filter {
public void init(FilterConfig filterConfig) throws ServletException {
}
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
//处理response的字符编码
HttpServletResponse myResponse = (HttpServletResponse)response;
myResponse.setContentType("text/html;charset=UTF-8");
//转型为与协议相关对象
HttpServletRequest httpServletRequest = (HttpServletRequest)request;
//对request包装增强
HttpServletRequest myRequest = new MyRequest(httpServletRequest);
chain.doFilter(request,response);
}
public void destroy() {
}
}
class MyRequest extends HttpServletRequestWrapper{
private HttpServletRequest request;
//是否编码的标记
private boolean hasEncode;
//定义一个可以传入HttpServletRequest对象的构造函数,以便对其进行装饰
public MyRequest(HttpServletRequest request) {
super(request);//super必须写
this.request = request;
}
@Override
public Map getParameterMap(){
String method = request.getMethod();
if(method.equalsIgnoreCase("post")){
//post请求
try{
request.setCharacterEncoding("utf-8");
return request.getParameterMap();
}catch (UnsupportedEncodingException e){
e.printStackTrace();
}
}else if(method.equalsIgnoreCase("get")){
//get请求
Map<String,String[]> parameterMap = request.getParameterMap();
if(!hasEncode){
for (String parameterName : parameterMap.keySet()) {
String[] values = parameterMap.get(parameterName);
if(values != null){
for (int i = 0; i < values.length; i++) {
try {
values[i] = new String(values[i].getBytes("ISO-8859-1"),"utf-8");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
}
}
}
hasEncode = true;
}
return parameterMap;
}
return super.getParameterMap();
}
//取一个值
@Override
public String getParameter(String name){
Map<String,String[]> parameterMap = getParameterMap();
String[] values = parameterMap.get(name);
if(values == null){
return null;
}
return values[0];//取回参数的第一个值
}
//取所有值
@Override
public String[] getParameterValues(String name) {
Map<String, String[]> parameterMap = getParameterMap();
String[] values = parameterMap.get(name);
return values;
}
}
<filter>
<filter-name>encoding</filter-name>
<filter-class>com.ljh.filter.GenericEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>utf-8</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>encoding</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
这个自定义乱码过滤器算是终极大招了,一般springmvc自带过滤器应该够了,如果不行,可以用它。
Spring:JSON
什么是JSON?
- JSON(javaScript Object Notation,JS对象标记)是一种轻量级的数据交换格式,目前使用特别广泛。
- 采用完全独立于编程语言的文本格式来存储和表示数据。
- 简洁和清晰的层次结构使得JSON成为理想的数据交换语言。
- 易于人阅读和编写,同时也易于机器解析和生成,并有效地提升网络传输效率。
在JavaScript语言中,一切都是对象。因此,任何JavaScript支持的类型都可以通过JSON来表示,例如字符串、数字、对象、数组等。看看他的要求和语法格式:
- 对象表示键值对,数据由逗号分隔
- 花括号保存对象
- 方括号保存数据
JSON键值对是用来保存JavaScript对象的一种方式,和JavaScript对象的写法也大同小异,键/值对组合中键名写在前面并用双引号""包裹,使用冒号:分隔,然后紧接着值:
{"name":"ljh"}
{"age":"3"}
{"sex":"男"}
很多人搞不清楚JSON和JavaScript对象的关系,甚至连谁是谁都不清楚,其实,可以这么理解:
- JSON是JavaScript对象的字符串表示法,它使用文本表示JS对象的信息,本质是一个字符串
var obj = {a:'Hello',b:'World'};//这是一个对象,注意键名也是可以使用引号包裹的
var json = '{"a":"Hello","b":"World"}';//这是一个JSON字符串,本质是一个字符串
JSON和JavaScript对象互转
- 要实现从JSON字符串转换为JavaScript对象,使用JSON.parse()方法:
var obj = JSON.parse('{"a":"Hello","b":"World"}');
//结果是{a:'Hello',b:'World'}
- 要实现从JavaScript对象转换为JSON字符串,使用JSON.stringfy()方法:
var json = JSON.stringfy({a:'Hello',b:'World'});
//结果是'{"a":"Hello","b":"World"}'
代码测试
- 新建一个module,springmvc05-json,添加web的支持
- 新建文件jsontest.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
<script type="text/javascript">
//编写一个javascript对象
var user = {
name:"ljh",
age:3,
sex:"男"
};
//将js对象转换为json对象
var json = JSON.stringify(user);
console.log(json);
console.log(user);
//将JSON对象转换为javascript对象
var obj = JSON.parse(json);
console.log(obj);
</script>
</head>
<body>
</body>
</html>
- 在IDEA中使用浏览器打开,查看控制台输出!
Controller返回JSON数据
- Jackson应该是目前比较好的json解析工具了
- 当然工具不止这一个,比如还有阿里巴巴的fastjson等等。
- 我们这里使用Jackson,使用它需要导入它的jar包;
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.8</version>
</dependency>
记得添加了依赖需要在Artifact里面的lib中添加进去
- 配置SpringMVC需要的配置
web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0">
<servlet>
<servlet-name>springmvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc-servlert.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
<filter>
<filter-name>encoding</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>encoding</filter-name>
<url-pattern>/</url-pattern>
</filter-mapping>
</web-app>
springmvc-servlert.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/mvc
http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.2.xsd">
<!--自动扫描包,让指定包下的注解生效,由IOC容器统一管理-->
<context:component-scan base-package="com.ljh.controller"/>
<mvc:default-servlet-handler/>
<mvc:annotation-driven/>
<!--视图解析器:DispatcherServlet给他的ModelAndView
1.获取了ModelAndView的数据
2.解析ModelAndView的视图名字
3.拼接视图名字,找到对应的视图 /WEB-INF/jsp/hello.jsp
4.将数据渲染到这个视图上
-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
<!--前缀-->
<property name="prefix" value="/WEB-INF/jsp/"/>
<!--后缀-->
<property name="suffix" value=".jsp"/>
</bean>
</beans>
- 我们随便编写一个User的实体类,然后我们去编写我们的测试Controller;
package com.ljh.pojo;
public class User {
private int id;
private String name;
private int age;
public User() {
}
public User(int id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
'}';
}
}
package com.ljh.controller;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.ljh.pojo.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
@Controller
public class UserCntroller {
@RequestMapping("/j1")
@ResponseBody
public String json1(){
//创建一个对象
User user = new User(1,"ljh",3);
return user.toString();
}
//produces:指定响应体返回类型和编码
@RequestMapping(value = "/j2",produces = "application/json;charset=utf-8")
@ResponseBody
public String json2() throws JsonProcessingException {
//jackson,ObjectMapper
ObjectMapper objectMapper = new ObjectMapper();
//创建一个对象
User user = new User(1,"李",3);
String s = objectMapper.writeValueAsString(user);
return s;
}
}
- 配置Tomcat,启动测试一下!
http://localhost:8080/j1
- 发现出现了乱码问题(如果没有配置乱码过滤器),我们需要设置一下它编码格式为utf-8,以及它返回的类型;
- 通过@RequestMapping的produces属性来实现,修改下代码
//produces:指定响应体返回类型和编码
@RequestMapping(value = "/j2",produces = "application/json;charset=utf-8")
- 再次测试,http://localhost:8080/j2,乱码问题OK!
【注意:使用json记得处理乱码问题】
代码优化
乱码统一解决
上一种方法比较麻烦,如果项目中有许多请求则每一个都要添加,可以通过Spring配置统一指定,这样就不用每次都去处理了!
我们可以在springmvc的配置文件上添加一段消息StringHttpMessageConverter转换配置!
<!--JSON乱码问题配置-->
<mvc:annotation-driven>
<mvc:message-converters>
<bean class="org.springframework.http.converter.StringHttpMessageConverter">
<constructor-arg value="UTF-8"/>
</bean>
<bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
<property name="objectMapper">
<bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
<property name="failOnEmptyBeans" value="false"/>
</bean>
</property>
</bean>
</mvc:message-converters>
</mvc:annotation-driven>
返回json字符串统一解决
在类上使用@RestController,这样子,里面所有的方法都只会返回json字符串了,不用在每一个都添加@ResonseBody!我们在前后端分离开发中,一般都使用@RestController,十分便捷!
@RestController
public class UserCntroller {
@RequestMapping("/j1")
public String json1(){
//创建一个对象
User user = new User(1,"ljh",3);
return user.toString();
}
}
启动tomcat测试,结果都正常输出!
测试集合输出
增加一个新的方法
@RestController
public class UserCntroller {
@RequestMapping("/j4")
public String json4() throws JsonProcessingException {
//jackson,ObjectMapper
ObjectMapper objectMapper = new ObjectMapper();
ArrayList<User> list = new ArrayList<User>();
//创建一个对象
User user = new User(1,"李",3);
User user1 = new User(2,"李",3);
User user2 = new User(3,"李",3);
list.add(user);
list.add(user1);
list.add(user2);
String s = objectMapper.writeValueAsString(list);
return s;
}
}
输出时间对象
增加一个新的方法
@RequestMapping("/j5")
public String json5() throws JsonProcessingException {
ObjectMapper objectMapper = new ObjectMapper();
//创建时间一个对象,java.util.Date
Date date = new Date();
String s = objectMapper.writeValueAsString(date);
return s;
}
运行结果:
- 默认日期格式会变成一个数字,是1970年1月1日到当前日期的毫秒数!
- Jackson默认是会把时间转换成timestamps形式
解决方案:取消timestamps形式,自定义时间格式
@RequestMapping("/j6")
public String json6() throws JsonProcessingException {
ObjectMapper objectMapper = new ObjectMapper();
//不使用时间戳的方式
objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false);
//自定义日期格式对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//指定日期格式
objectMapper.setDateFormat(sdf);
Date date = new Date();
String s = objectMapper.writeValueAsString(date);
return s;
}
运行结果,成功的输出了时间!
抽取为工具类
如果要经常使用的话,这样是比较麻烦的,我们可以将这些代码封装到一个工具类中;我们去编写下
package com.ljh.utils;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import java.text.SimpleDateFormat;
public class JsonUtils {
public static String getJson(Object object){
ObjectMapper objectMapper = new ObjectMapper();
try {
return objectMapper.writeValueAsString(object);
} catch (JsonProcessingException e) {
e.printStackTrace();
}
return null;
}
public static String getJson(Object object,String dateFormat){
ObjectMapper objectMapper = new ObjectMapper();
//不使用时间戳的方式
objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false);
//自定义日期格式对象
SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
//指定日期格式
objectMapper.setDateFormat(sdf);
try {
return objectMapper.writeValueAsString(object);
} catch (JsonProcessingException e) {
e.printStackTrace();
}
return null;
}
}
大功告成,完美!
FastJson
fastjson.jar是阿里开发的一款专门用于Java开发的包,可以方便的实现json对象与JavaBean对象的转换,实现JavaBean对象与json字符串的转换,实现json对象与json字符串的转换。实现json转换方法很多,最后的实现结果都是一样的。
fastjson的pom依赖!
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.60</version>
</dependency>
fastjson三个主要的类:
- 【JSONObject代表json对象】
- JSONObject实现了Map接口,才想JSONObject底层操作是由Map实现的。
- JSONObject对应json对象,通过各种形式的get()方法可以获取json对象中的数据,也可利用诸如size(),isEmpty()等方法获取“键:值”对的个数和判断是否为空。其本质是通过实现
- 【JSONArray代表json对象数组】
- 内部是有List接口中的方法来完成操作的。
- 【JSON代表JSONObject和JSONArray的转化】
- JSON类源码分析与使用
- 仔细观察这些方法,主要是实现json对象,json对象数组,javabean对象,json字符串之间的相互转化。
代码测试
@RequestMapping("/j7")
public String json7(){
ArrayList<User> list = new ArrayList<User>();
//创建一个对象
User user = new User(1,"李",3);
User user1 = new User(2,"李",3);
User user2 = new User(3,"李",3);
list.add(user);
list.add(user1);
list.add(user2);
System.out.println("=========Java对象 转 JSON字符串===========");
String s = JSON.toJSONString(list);
String s1 = JSON.toJSONString(user);
System.out.println("=========JSON字符串 转 Java对象===========");
User user3 = JSON.parseObject(s1, User.class);
System.out.println("=========JSON.parseObject(s1, User.class)====>"+user3);
System.out.println("=========JSON字符串 转 Java数组===========");
List<User> list1 = JSON.parseArray(s, User.class);
System.out.println("=========JSON.parseArray(s, User.class)====>"+list1);
System.out.println("=========JSON字符串 转 JSON字符串数组===========");
JSONArray list2 = JSON.parseArray(s);
System.out.println("=========JSON.parseArray(s)====>"+list2);
System.out.println("========Java对象 转 JSON对象========");
JSONObject jsonObject = (JSONObject)JSON.toJSON(user2);
System.out.println("(JSONObject)JSON.toJSON(user2)====>"+jsonObject);
System.out.println("==========JSON对象 转 Java对象============");
User user4 = JSON.toJavaObject(jsonObject, User.class);
System.out.println("JSON.toJavaObject(jsonObject, User.class)==>"+user4);
return "Hello";
}
这种工具类,我们只需要掌握使用就好了,在使用的时候再根据具体的业务去找对应的实现。和以前的commons-io那种工具包一样,拿来用就好了!
SpringMVC:整合SSM
环境需求
环境:
- IDEA
- MySQL 5.7.19
- Tomcat 9
- Maven 3.6
要求:
- 需要熟练掌握MySQL数据库,Spring,JavaWeb及MyBatis知识,简单的前端知识;
数据库环境
创建一个存放数据数据的数据库表
CREATE DATABASE 'ssmbuild';
USE 'ssmbuild';
DROP TABLE IF EXISTS 'books';
CREATE TABLE `books` (
`bookID` int(10) NOT NULL AUTO_INCREMENT COMMENT '书id',
`bookName` varchar(100) NOT NULL COMMENT '书名',
`bookCounts` int(11) NOT NULL COMMENT '数量',
`detail` varchar(200) NOT NULL COMMENT '描述',
PRIMARY KEY (`bookID`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
INSERT INTO `ssmbuild`.`books`(`bookID`, `bookName`, `bookCounts`, `detail`) VALUES (1, 'JAVA', 1, '从入门到放弃');
INSERT INTO `ssmbuild`.`books`(`bookID`, `bookName`, `bookCounts`, `detail`) VALUES (2, 'MySQL', 10, '删库跑路');
INSERT INTO `ssmbuild`.`books`(`bookID`, `bookName`, `bookCounts`, `detail`) VALUES (3, 'Linux', 5, '从进门到进牢');
基本环境搭建
- 新建一个Maven项目!ssmbuild,添加web的支持
- 导入相关的pom依赖
<!--依赖:junit,数据库驱动,连接池,servlet,jsp,mybatis,mybatis-spring,spring-->
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.47</version>
</dependency>
<!--数据库连接池:C3P0,dbcp-->
<dependency>
<groupId>com.mchange</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.5.2</version>
</dependency>
<!--Servlet - JSP-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
</dependency>
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>javax.servlet.jsp-api</artifactId>
<version>2.3.1</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
<!--Mybatis-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.2</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>2.0.2</version>
</dependency>
<!--Spring-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.0.RELEASE</version>
</dependency>
<!--Spring操作数据库的话,还需要一个spring-jdbc-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.1.9.RELEASE</version>
</dependency>
</dependencies>
- Maven资源过滤设置
<!--静态资源导出问题-->
<build>
<resources>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>false</filtering>
</resource>
<resource>
<directory>src/main/resources</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>false</filtering>
</resource>
</resources>
</build>
- 建立基本结构和配置框架!
-
com.ljh.pojo
-
com.ljh.controller
-
com.ljh.dao
-
com.ljh.service
-
mybatis-config.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>
- 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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
</beans>
Mybatis层编写
- 数据库配置文件database.properties
jdbc.driver=com.mysql.jdbc.Driver
#如果使用的是MySQL8.0+,需要加上失去的配置: &serverTimezone=Asia/Shanghai
jdbc.url=jdbc:mysql://localhost:3306/ssmbuild?useUnicode=true&characterEncoding=utf8&useSSL=true
jdbc.username=root
jdbc.password=123456
- IDEA关联数据库
- 编写MyBatis的核心配置文件
<?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核心配置文件-->
<configuration>
<typeAliases>
<package name="com.ljh.pojo"/>
</typeAliases>
<mappers>
<mapper class="com.ljh.dao.BookMapper"/>
</mappers>
</configuration>
- 编写数据库对应的实体类com.ljh.Books
package com.ljh.pojo;
public class Books {
private int bookID;
private String bookName;
private int bookCounts;
private String detail;
public Books() {
}
public Books(int bookID, String bookName, int bookCounts, String detail) {
this.bookID = bookID;
this.bookName = bookName;
this.bookCounts = bookCounts;
this.detail = detail;
}
public int getBookID() {
return bookID;
}
public void setBookID(int bookID) {
this.bookID = bookID;
}
public String getBookName() {
return bookName;
}
public void setBookName(String bookName) {
this.bookName = bookName;
}
public int getBookCounts() {
return bookCounts;
}
public void setBookCounts(int bookCounts) {
this.bookCounts = bookCounts;
}
public String getDetail() {
return detail;
}
public void setDetail(String detail) {
this.detail = detail;
}
@Override
public String toString() {
return "Books{" +
"bookID=" + bookID +
", bookName='" + bookName + '\'' +
", bookCounts=" + bookCounts +
", detail='" + detail + '\'' +
'}';
}
}
- 编写Dao层的Mapper接口
package com.ljh.dao;
import com.ljh.pojo.Books;
import java.util.List;
public interface BookMapper {
//增加一本书
int addBook(Books books);
//删除一本书
int deleteBookById(int id);
//更新一本书
int updateBook(Books books);
//查询一本书
Books queryBooksById(int id);
//查询全部的书
List<Books> queryAllBooks();
}
- 编写接口对应的Mapper.xml文件,需要导入MyBatis的包:
<?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">
<!--nameSpace绑定一个对应的Dao/Mapper接口-->
<mapper namespace="com.ljh.dao.BookMapper">
<insert id="addBook" parameterType="Books">
insert into books (bookName,bookCounts,detail) values (#{bookName},#{bookCounts},#{detail})
</insert>
<delete id="deleteBookById" parameterType="int">
delete from books where bookID=#{bookID}
</delete>
<update id="updateBook" parameterType="Books">
update books set bookName =#{bookName},bookCounts=#{bookCounts},detail=#{detail} where bookID=#{bookID}
</update>
<select id="queryBooksById" resultType="Books">
select * from books where bookID=#{bookID}
</select>
<select id="queryAllBooks" resultType="Books">
select * from books
</select>
</mapper>
- 编写Service层的接口和实现类
接口:
package com.ljh.service;
import com.ljh.pojo.Books;
import java.util.List;
public interface BookService {
//增加一本书
int addBook(Books books);
//删除一本书
int deleteBookById(int id);
//更新一本书
int updateBook(Books books);
//查询一本书
Books queryBooksById(int id);
//查询全部的书
List<Books> queryAllBooks();
}
实现类:
package com.ljh.service;
import com.ljh.dao.BookMapper;
import com.ljh.pojo.Books;
import java.util.List;
public class BookServiceImpl implements BookService {
private BookMapper bookMapper;
public void setBookMapper(BookMapper bookMapper) {
this.bookMapper = bookMapper;
}
public int addBook(Books books) {
return bookMapper.addBook(books);
}
public int deleteBookById(int id) {
return bookMapper.deleteBookById(id);
}
public int updateBook(Books books) {
return bookMapper.updateBook(books);
}
public Books queryBooksById(int id) {
return bookMapper.queryBooksById(id);
}
public List<Books> queryAllBooks() {
return bookMapper.queryAllBooks();
}
}
ok,到此,底层需求操作编写完毕!
Spring层
- 配置Spring整合MyBatis,我们这里数据源使用c3p0连接池
- 我们去编写Spring整合Mybatis的相关的配置文件:spring-dao.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:util="http://www.springframework.org/schema/util"
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
https://www.springframework.org/schema/context/spring-context.xsd">
<!--1.关联数据库配置文件-->
<context:property-placeholder location="classpath:database.properties"/>
<!--2.连接池
dbcp:班自动化操作,不能自动连接
c3p0:自动化操作(自动化的加载配置文件,并且可以自动配置到对象中!)
druid:hikari
-->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="${jdbc.driver}"/>
<property name="jdbcUrl" value="${jdbc.url}"/>
<property name="user" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
<!--c3p0连接池的私有属性-->
<property name="maxPoolSize" value="30"/>
<property name="minPoolSize" value="10"/>
<!--关闭连接后不自动commit-->
<property name="autoCommitOnClose" value="false"/>
<!--获取连接超时时间-->
<property name="checkoutTimeout" value="10000"/>
<!--当获取连接失败重试次数-->
<property name="acquireRetryAttempts" value="2"/>
</bean>
<!--2.sqlSessionFactory-->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"/>
<!--绑定Mybatis的配置文件-->
<property name="configLocation" value="classpath:mybatis-config.xml"/>
</bean>
<!--4.配置dao接口扫描包,动态的实现了Dao接口可以注入到Spring容器中! -->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
<!--要扫描的dao包-->
<property name="basePackage" value="com.ljh.dao"/>
</bean>
</beans>
- Spring整合service层
<?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 https://www.springframework.org/schema/context/spring-context.xsd">
<!--1.扫描service下的包-->
<context:component-scan base-package="com.ljh.service"/>
<!--2.将我们的所有业务类,注入到Spring,可以通过配置,或者注解实现-->
<bean id="BookServiceImpl" class="com.ljh.service.BookServiceImpl">
<property name="bookMapper" ref="bookMapper"/>
</bean>
<!--3.声明式事务配置-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!--注入数据源-->
<property name="dataSource" ref="dataSource"/>
</bean>
<!--4.aop事务支持-->
<!--结合AOP实现事务的织入-->
<!--配置事务通知:-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<!--给那些方法配置事务-->
<!-- <tx:attributes>-->
<!-- <tx:method name="add" propagation="REQUIRED"/>-->
<!-- <tx:method name="delete" propagation="REQUIRED"/>-->
<!-- <tx:method name="update" propagation="REQUIRED"/>-->
<!-- <tx:method name="query" read-only="true"/>-->
<!-- <tx:method name="*" propagation="REQUIRED"/>-->
<!-- </tx:attributes>-->
</tx:advice>
<!--配置事务切入-->
<aop:config>
<aop:pointcut id="txPointCut" expression="execution(* com.ljh.dao.*.*(..))"/>
<aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
</aop:config>
</beans>
Spring层搞定!再次理解一下,Spring就是一个大杂烩,一个容器!对吧!
SpringMVC层
- web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0">
<!--DispatcherServlet-->
<servlet>
<servlet-name>springmvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:applicationContext.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
<!--乱码时过滤-->
<filter>
<filter-name>encoding</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>encoding</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<!--Session-->
<session-config>
<session-timeout>15</session-timeout>
</session-config>
</web-app>
- spring-mvc
<?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/mvc
http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.2.xsd">
<!--1.注解驱动-->
<mvc:annotation-driven/>
<!--2.静态资源过滤-->
<mvc:default-servlet-handler/>
<!--3.扫描包:controller-->
<context:component-scan base-package="com.ljh.controller"/>
<!--4.视图解析器-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/jsp/"/>
<property name="suffix" value=".jsp"/>
</bean>
</beans>
- Spring配置整合文件,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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<import resource="classpath:spring-dao.xml"/>
<import resource="classpath:spring-service.xml"/>
<import resource="classpath:spring-mvc.xml"/>
</beans>
配置文件,暂时结束!Controller和视图层编写
- BookController类编写,方法一:查询全部书籍
package com.ljh.controller;
import com.ljh.pojo.Books;
import com.ljh.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import java.util.ArrayList;
import java.util.List;
@Controller
@RequestMapping("/book")
public class BookController {
//controller调用service层
@Autowired
@Qualifier("BookServiceImpl")
private BookService bookService;
@RequestMapping("/allBook")
public String list(Model model){
List<Books> list = bookService.queryAllBooks();
model.addAttribute("list",list);
return "allBook";
}
@RequestMapping("/toAddBook")
//跳转到增加书籍页面
public String toAddBook(){
return "addBook";
}
@RequestMapping("/addBook")
//增加书籍请求
public String addBook(Books books){
System.out.println(books);
bookService.addBook(books);
return "redirect:/book/allBook";
}
@RequestMapping("/toUpdateBook")
//跳转到修改书籍页面
public String toUpdateBook(int id,Model model){
Books books = bookService.queryBooksById(id);
model.addAttribute("books",books);
return "updateBook";
}
@RequestMapping("/updateBook")
//修改书籍请求
public String updateBook(Books books){
System.out.println(books);
bookService.addBook(books);
return "redirect:/book/allBook";
}
@RequestMapping("/deleteBook")
//删除书籍请求
public String deleteBook(int id){
bookService.deleteBookById(id);
return "redirect:/book/allBook";
}
@RequestMapping("/queryBook")
//删除书籍请求
public String queryBook(String queryName,Model model){
List<Books> list = bookService.queryBooks(queryName);
if(list.size()==0){
model.addAttribute("error","未查到");
}
model.addAttribute("list",list);
return "allBook";
}
}
- 编写首页index.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>首页</title>
<style>
a{
text-decoration: none;
color: black;
font-size: 18px;
}
h3{
width: 180px;
height: 38px;
margin: 100px auto;
text-align: center;
line-height: 38px;
background: deepskyblue;
border-radius: 5px;
}
</style>
</head>
<body>
<h3>
<a href="${pageContext.request.contextPath}/book/allBook">进入书籍页面</a>
</h3>
</body>
</html>
- 书籍列表页面allbook.jsp
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>书籍展示</title>
<!-- 新 Bootstrap 核心 CSS 文件 -->
<link href="https://cdn.staticfile.org/twitter-bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
<%-- <!-- jQuery文件。务必在bootstrap.min.js 之前引入 -->--%>
<%-- <script src="https://cdn.staticfile.org/jquery/2.1.1/jquery.min.js"></script>--%>
<%-- <!-- 最新的 Bootstrap 核心 JavaScript 文件 -->--%>
<%-- <script src="https://cdn.staticfile.org/twitter-bootstrap/3.3.7/js/bootstrap.min.js"></script>--%>
</head>
<body>
<div class="container">
<div class="row clearfix">
<div class="col-md-12 column">
<div class="page-header">
<h1>
<small>书籍列表————显示所有书籍</small>
</h1>
</div>
</div>
<div class="row">
<div class="col-md-4 column">
<a class="btn btn-primary" href="${pageContext.request.contextPath}/book/toAddBook">增加书籍</a>
</div>
<div class="col-md-4 column">
<a class="btn btn-primary" href="${pageContext.request.contextPath}/book/allBook">显示所有书籍</a>
</div>
<div class="col-md-4 column" style="float: right">
<form action="${pageContext.request.contextPath}/book/queryBook" method="">
<input type="text" class="form-control" name="queryName" placeholder="请输入要查询的书籍名称">
<input type="submit" value="查询" class="btn btn-primary">
</form>
</div>
</div>
</div>
<div class="row clearfix">
<div class="col-md-12 column">
<table class="table table-hover table-striped">
<thead>
<tr>
<th>书籍编号</th>
<th>书籍名称</th>
<th>书籍数量</th>
<th>书籍详情</th>
<th>操作</th>
</tr>
</thead>
<%--书籍从数据库中查询出来,从这个list中遍历出来:foreach--%>
<tbody>
<c:if test="${error!=null}">
<tr>${error}</tr>
</c:if>
<c:if test="${error == null}">
<c:forEach var="book" items="${list}">
<tr>
<td>${book.bookID}</td>
<td>${book.bookName}</td>
<td>${book.bookCounts}</td>
<td>${book.detail}</td>
<td>
<a href="${pageContext.request.contextPath}/book/toUpdateBook?id=${book.bookID}">修改</a>
|
<a href="${pageContext.request.contextPath}/book/deleteBook?id=${book.bookID}">删除</a>
</td>
</tr>
</c:forEach>
</c:if>
</tbody>
</table>
</div>
</div>
</div>
</body>
</html>
- 添加书籍页面addBook.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
<link href="https://cdn.staticfile.org/twitter-bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
</head>
<body>
<div class="container">
<div class="row clearfix">
<div class="col-md-12 column">
<div class="page-header">
<h1>
<small>新增书籍</small>
</h1>
</div>
</div>
</div>
<form action="${pageContext.request.contextPath}/book/addBook" method="post">
<div class="form-group">
<label >书籍名称</label>
<input type="text" name="bookName" class="form-control" required>
</div>
<div class="form-group">
<label >书籍数量</label>
<input type="text" name="bookCounts" class="form-control" required>
</div>
<div class="form-group">
<label >书籍描述</label>
<input type="text" name="detail" class="form-control" required>
</div>
<div class="form-group">
<input type="submit" class="form-control" value="增加">
</div>
</form>
</div>
</body>
</html>
- 修改书籍页面updateBook.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
<link href="https://cdn.staticfile.org/twitter-bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
</head>
<body>
<div class="container">
<div class="row clearfix">
<div class="col-md-12 column">
<div class="page-header">
<h1>
<small>修改书籍</small>
</h1>
</div>
</div>
</div>
<form action="${pageContext.request.contextPath}/book/updateBook" method="post">
<div class="form-group">
<label >书籍名称</label>
<input type="text" name="bookName" value="${books.bookName}" class="form-control" required>
</div>
<div class="form-group">
<label >书籍数量</label>
<input type="text" name="bookCounts" value="${books.bookCounts}" class="form-control" required>
</div>
<div class="form-group">
<label >书籍描述</label>
<input type="text" name="detail" value="${books.detail}" class="form-control" required>
</div>
<div class="form-group">
<input type="submit" class="form-control" value="修改">
</div>
</form>
</div>
</body>
</html>
配置Tomcat,进行运行!
别目前为止,这个SSM项目整合已经完全OK了,可以直接运行进行测试!这个练习十分的重要,需要保证,不看任何东西,自己也可以完整的实现出来
项目结构图
小结及展望
这个是一个完整的SSM整合案例,一定要烂熟于胸!!!
SSM框架的重要程度是不言而喻的。
SpringMVC:Ajax技术
简介
- AJAX=Asynchronous JavaScript and XML(异步的JavaScript和XML)。
- AJAX是一种无需重新加载整个页面的情况下,能够更新部分页面的技术。
- Ajax不是一种新的编程语言,而是一种用于创建更好更快以及交互性更强的Web应用程序的技术
- 在2005年,Google通过其Google Suggest使AJAX变得流行起来,Google Suggest能够自动帮你完成搜索单词。
- Google Suggest使用AJAX创造出动态性极强的web界面:当你在谷歌搜索框输入关键字时,JavaScript会把这些字符发送到服务器,然后服务器会返回一个搜索建议的列表
- 传统的网页(即不用ajax技术的页面),想要更新内容或者提交一个表单,都需要重新加载整个网页。
- 使用ajax技术的网页,通过在后台服务器进行少量的数据交换,就可以实现异步局部更新
- 使用ajax,用户可以创建接近本地桌面应用的直接、高可用、更丰富、更动态的Web用户界面。
伪造Ajax
我们可以使用前端的一个标签来伪造一个ajax的样子。iframe标签
- 新建一个module springmvc06-ajax,导入web支持!
- 编写一个ajax-frame.html使用iframe测试,感受下效果
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>iframe测试体验页面无刷新</title>
<script type="text/javascript">
function go() {
var url = document.getElementById("url").value;
document.getElementById("iframe1").src=url;
}
</script>
</head>
<body>
<div>
<p>请输入地址:</p>
<p>
<input type="text" id="url" value="https://www.baidu.com">
<input type="submit" value="提交" onclick="go()">
</p>
</div>
<div>
<iframe id="iframe1" style="width: 100%;height: 500px"></iframe>
</div>
</body>
</html>
- 使用IDEA开浏览器测试一下!
利用AJAX可以做:
- 注册时,输入用户名自动检测用户是否已经存在。
- 登陆时,提示用户名密码错误
- 删除数据行时,将ID发送到后台,后台在数据库中删除,数据库删除成功后,在页面DOM中将数据行也删除。
- …等待
jQuery.ajax
- 纯JS原生实现Ajax我们暂时不看,直接使用jquery提供的,方便学习和使用,避免重复造轮子,有兴趣可以了解一下JS原生XMLHttpRequest!
- Ajax的核心是XMLHttpRequest对象(XHR)。XHR为向服务器发送请求和解析服务器响应提供了接口。能够以异步方式从服务器获取新数据。
- jQuery提供多个与AJAX有关的方法。
- 通过jQuery AJAX方法,你能够使用HTTP Get和HTTP Post从远程服务器上请求文本、HTML、XML或JSON-同时你能够把这些外部数据直接载入网页的被选元素中。
- jQuery不是生产者,而是大自然的搬运工。
- jQuery Ajax本质就是XMLHttpRequest,对他进行了封装,方便调用!
做个简单的测试,使用最原始的HttpServletResponse处理,最简单,最通用
- 配置web.xml和springmvc的配置文件,复制上面案例的即可【记得静态资源过滤和注解驱动配置上】
<?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:contex="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 https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">
<contex:component-scan base-package="com.ljh.controller"/>
<mvc:default-servlet-handler/>
<mvc:annotation-driven/>
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
<property name="prefix" value="/WEB-INF/jsp/"/>
<property name="suffix" value=".jsp"/>
</bean>
</beans>
- 编写一个AjaxController
package com.ljh.controller;
import com.ljh.pojo.User;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
@RestController
public class AjaxController {
@RequestMapping("/t1")
public String test(){
return "hello";
}
@RequestMapping("/a1")
public void test1(String name, HttpServletResponse response) throws IOException {
if("ljh".equals(name)){
response.getWriter().println("true");
}else {
response.getWriter().println("false");
}
}
@RequestMapping("/a2")
public List<User> test2(String name) throws IOException {
ArrayList<User> list = new ArrayList<User>();
list.add(new User("ljh",1,"男"));
list.add(new User("ljh1",2,"男"));
return list;
}
@RequestMapping("/a3")
public String test3(String name,String pwd) throws IOException {
String msg = "";
if(name != null){
if("admin".equals(name)){
msg = "ok";
}else {
msg = "用户名有误";
}
}
if(pwd != null){
if("123456".equals(pwd)){
msg = "ok";
}else {
msg = "密码有误";
}
}
return msg;
}
}
写一个User类
package com.ljh.pojo;
public class User {
private String name;
private int age;
private String sex;
public User() {
}
public User(String name, int age, String sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
", sex='" + sex + '\'' +
'}';
}
}
- index.jsp,失去光标触发alert
<%--
Created by IntelliJ IDEA.
User: 86136
Date: 2021/6/26
Time: 20:07
To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>$Title$</title>
<script src="${pageContext.request.contextPath}/statics/js/jquery-3.6.0.js"></script>
<script>
function a(){
$.post({
url:"${pageContext.request.contextPath}/a1",
data:{"name":$("#username").val()},
success:function (data) {
alert(data);
}
})
}
</script>
</head>
<body>
<%-- 失去焦点的时候,发起一个请求到后台--%>
用户名:<input type="text" id="username" οnblur="a()">
</body>
</html>
- 手动触发,收集数据test2.jsp
<%--
Created by IntelliJ IDEA.
User: 86136
Date: 2021/6/26
Time: 23:29
To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
<script src="${pageContext.request.contextPath}/statics/js/jquery-3.6.0.js"></script>
<script>
$(function () {
$("#btn").click(function () {
console.log("222");
$.post("${pageContext.request.contextPath}/a2",function (data) {
console.log(data);
var html = "<>";
for (let i=0;i<data.length;i++){
html+="<tr>"
+"<td>"+data[i].name+"</td>"
+"<td>"+data[i].age+"</td>"
+"<td>"+data[i].sex+"</td>"
+"</tr>";
}
$("#content").html(html);
});
})
});
</script>
</head>
<body>
<input type="button" value="加载数据" id="btn">
<table>
<tr>
<td>姓名</td>
<td>年龄</td>
<td>性别</td>
</tr>
<tbody id="content">
<%----%>
</tbody>
</table>
</body>
</html>
5. 验证用户名
<%--
Created by IntelliJ IDEA.
User: 86136
Date: 2021/6/27
Time: 0:09
To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
<script src="${pageContext.request.contextPath}/statics/js/jquery-3.6.0.js"></script>
<script>
function a1() {
$.post({
url:"${pageContext.request.contextPath}/a3",
data:{"name":$("#name").val()},
success:function (data) {
if(data.toString() == "ok"){
$("#userInfo").css("color","green")
}else {
$("#userInfo").css("color","red")
}
console.log(data);
$("#userInfo").html(data);
}
})
}
function a2() {
$.post({
url:"${pageContext.request.contextPath}/a3",
data:{"pwd":$("#pwd").val()},
success:function (data) {
if(data.toString() == "123456"){
$("#pwdInfo").css("color","green")
}else {
$("#pwdInfo").css("color","red")
}
$("#pwdInfo").html(data);
}
})
}
</script>
</head>
<body>
<p>
用户名:<input type="text" id="name" οnblur="a1()">
<span id="userInfo"></span>
</p>
<p>
用户名:<input type="text" id="pwd" οnblur="a2()">
<span id="pwdInfo"></span>
</p>
</body>
</html>
中文如果乱码,记得加上
<!--JSON乱码问题配置-->
<mvc:annotation-driven>
<mvc:message-converters>
<bean class="org.springframework.http.converter.StringHttpMessageConverter">
<constructor-arg value="UTF-8"/>
</bean>
<bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
<property name="objectMapper">
<bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
<property name="failOnEmptyBeans" value="false"/>
</bean>
</property>
</bean>
</mvc:message-converters>
</mvc:annotation-driven>
SpringMVC:拦截器
概述
SpringMVC的处理器拦截器类似与Servlet开发中的过滤器Filter,用于对处理器进行预处理和后处理,开发者可以自己定义一些拦截器来实现特定的功能。
**过滤器与拦截器的区别:**拦截器是AOP思想的具体应用。
过滤器
- servlet规范中的一部分,任何Java web工程都可以使用
- 在url-pattern中配置了/*之后,可以对所有要访问的资源进行拦截
拦截器
- 拦截器是SpringMVC框架自己的,只有使用了SpringMVC框架的工程才能使用
- 拦截器只会拦截访问的控制器方法,如果访问的是jsp/html/css/image/js是不会进行拦截的
自定义拦截器
那如何实现拦截器呢?
想要自定义拦截器,必须实现HandlerInterceptor接口。
- 新建一个Module,springmvc07-intercepter,添加web支持
- 配置web.xml和springmvc-servlet.xml文件
- 编写一个拦截器
package com.ljh.config;
import org.springframework.lang.Nullable;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class MyInterceptor implements HandlerInterceptor {
//return true;执行下一个拦截器,放行
//return true;不执行下一个拦截器
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {
System.out.println("处理前");
return true;
}
//日志
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
@Nullable ModelAndView modelAndView) throws Exception {
System.out.println("处理后");
}
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,
@Nullable Exception ex) throws Exception {
System.out.println("清理");
}
}
- 配置拦截
<!--拦截器配置-->
<mvc:interceptors>
<mvc:interceptor>
<!--包括这个请求下面的所有的请求-->
<mvc:mapping path="/**"/>
<bean class="com.ljh.config.MyInterceptor"/>
</mvc:interceptor>
<mvc:interceptor>
<!--包括这个请求下面的所有的请求-->
<mvc:mapping path="/user/**"/>
<bean class="com.ljh.config.LoginInterceptor"/>
</mvc:interceptor>
</mvc:interceptors>
- controller
package com.ljh.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class TestController {
@RequestMapping("/t1")
public String test(){
System.out.println("TestController==>test()执行了");
return "ok";
}
}
SpringMVC:文件上传和下载
准备工作
文件上传
一、导入文件上传的jar包,commons-fileupload,Maven会自动帮我们导入他的依赖包commons-io包;
<!--文件上传-->
<dependencies>
<dependency>
<groupId>commons-fileupload</groupId>
<artifactId>commons-fileupload</artifactId>
<version>1.3.3</version>
</dependency>
<!--servlet-api导入高版本的-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>4.0.1</version>
</dependency>
</dependencies>
二、配置bean:multipartResolver
【注意!!!!这个bean的id必须为multipartResolver,否则上次文件会报400的错误!,在这里栽过坑,教训!】
<!--文件上传配置-->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
<!--请求的编码格式,必须和jsp的pageEncoding属性一致,以便正确读取表单的内容,默认为ISO-8859-->
<property name="defaultEncoding" value="utf-8"/>
<!--上传文件大小上限,单位为字节(10485760=10M)-->
<property name="maxUploadSize" value="10485760"/>
<property name="maxInMemorySize" value="40960"/>
</bean>
CommonsMultipartFile的常用方法:
- String getOriginalFilename():获取上传文件的原名
- inputStream getInputStream():获取文件流
- void transferTo(File dest) :将上传文件保存到一个目录文件中
我们去实际测试一下
三、编写前端页面
<form action="${pageContext.request.contextPath}/upload" method="post" enctype="multipart/form-data">
<input type="file" name="file"/>
<input type="submit" value="upload">
</form>
四、Controller
package com.ljh.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.commons.CommonsMultipartFile;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.net.URLEncoder;
@RestController
public class FileCnotroller {
@RequestMapping("/upload")
public String test(@RequestParam("file")CommonsMultipartFile file, HttpServletRequest request) throws IOException {
//获取文件名:file.getOriginalFilename();
String uploadFilename = file.getOriginalFilename();
//如果文件名为空,直接回到首页!
if("".equals(uploadFilename)){
return "redirect:/index.jsp";
}
System.out.println("上传文件名:"+uploadFilename);
//上传路径保存设置
String path = request.getServletContext().getRealPath("/upload");
//如果路径不存在,创建一个
File realPath = new File(path);
if(!realPath.exists()){
realPath.mkdir();
}
System.out.println("上传文件保存地址:"+realPath);
InputStream is = file.getInputStream();//文件输入流
FileOutputStream os = new FileOutputStream(new File(realPath, uploadFilename));//文件输出流
//读取写出
int len=0;
byte[] buffer = new byte[1024];
while ((len=is.read(buffer))!=-1){
os.write(buffer,0,len);
os.flush();
}
os.close();
is.close();
return "redirect:/index.jsp";
}
/**
* transferTo方法
* @param file
* @param request
* @return
* @throws IOException
*/
@RequestMapping("/upload2")
public String fileUpload(@RequestParam("file")CommonsMultipartFile file,HttpServletRequest request) throws IOException {
//上传路径保存设置
String path = request.getServletContext().getRealPath("/upload");
File realPath = new File(path);
if(!realPath.exists()){
realPath.mkdir();
}
//上传文件地址
System.out.println("上传文件保存地址:"+realPath);
//通过CommonsMultipaartFile的方法直接写文件(注意这个时候)
file.transferTo(new File(realPath+"/"+file.getOriginalFilename()));
return "redirect:/index.jsp";
}
@RequestMapping("/download")
public String downloads(HttpServletResponse response,HttpServletRequest request) throws IOException {
//要下载的图片地址
String path = request.getServletContext().getRealPath("/upload");
String fileName = "dd.txt";
//1.设置response响应头
response.reset();//设置页面不缓存,清空buffer
response.setCharacterEncoding("UTF-8");//字符编码
response.setContentType("multipart/form-data");//二进制传输数据
//设置响应头
response.setHeader("Content-Disposition","attachment,fileName="+ URLEncoder.encode(fileName,"UTF-8"));
File file = new File(path, fileName);
//2.读取文件--输入流
FileInputStream input = new FileInputStream(file);
//3.写出文件--输出流
ServletOutputStream out = response.getOutputStream();
byte[] buff = new byte[1024];
int index = 0;
//4.执行写出操作
while ((index=input.read(buff))!=-1){
out.write(buff,0,index);
out.flush();
}
out.close();
input.close();
return "ok";
}
}