package com.sise.controller;
import com.sise.domain.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Map;
@Controller
@RequestMapping(path = "/twoCOntroller")
public class TwoCOntroller {
@RequestMapping("testForWare")
public void testForWare(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
request.getRequestDispatcher("/WEB-INF/pages/Twosuccess.jsp").forward(request,response);
}
/**
需要注意的是，如果用了 formward：则路径必须写成实际视图 url，不能写逻辑视图。
它相当于“request.getRequestDispatcher("url").forward(request,response)”。使用请求
转发，既可以转发到 jsp，也可以转发到其他的控制器方法。*/
@RequestMapping("testsendRedirect")
public void TestsendRedirect(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
response.sendRedirect(request.getContextPath()+"/Threesuccess.jsp");
//它相当于“response.sendRedirect(url)”。需要注意的是，如果是重定向到 jsp 页面，则 jsp 页面不
//能写在 WEB-INF 目录中，否则无法找到。
}
@RequestMapping("ResponseForWare")
public String ResponseForWare(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
System.out.println("ResponseForWare");
return "forward:/WEB-INF/pages/Twosuccess.jsp";
}
@RequestMapping("ResponseRedirect")
public String ResponseRedirect(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
System.out.println("ResponseRedirect");
//它相当于“response.sendRedirect(url)”。需要注意的是，如果是重定向到 jsp 页面，则 jsp 页面不
//能写在 WEB-INF 目录中，否则无法找到。
return "redirect:Threesuccess.jsp";
}
/*
以下配置就是告诉前端控制器那些资源不拦截，所谓的拦截就是这个图片要显示，但是被这个
前端控制器拦截了，因此图片显示不出，因此我们要设置，那些资源不拦截，一般静态资源都不拦截
<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:springmvc.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dispatcherServlet</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
让前端控制器不拦截静态资源的设置方式
location：本地目录
mapping：地址栏上的含有这些/css/等都不拦截
* <mvc:resources location="/css/" mapping="/css/**"/>
<mvc:resources location="/images/" mapping="/images/**"/>
<mvc:resources location="/js/" mapping="/js/**"/>
*
*
*/
/*
1.1.3 ModelAndView
* ModelAndView返回值
* 可以存储对象也可以直接通过视图解析器访问页面
ModelAndView mv = new ModelAndView();
mv.addObject("username", "张三");
mv.setViewName("success");
ModelAndView av=new ModelAndView();
av.addObject("wangcx","mingzi");
Map<String, Object> map = av.getModel();
String wangcx = (String) map.get("wangcx");
System.out.println(wangcx);
av.setViewName("success");
return av;
@RequestMapping(value="/testSessionAttributes")
public String testSessionAttributes(Model model){
System.out.println("testSessionAttributes...");
// 底层会存储到request域对象中
model.addAttribute("msg","美美");
return "success";
}
@RequestMapping(value="/getSessionAttributes")
public String getSessionAttributes(ModelMap modelMap){
System.out.println("getSessionAttributes...");
String msg = (String) modelMap.get("msg");
System.out.println(msg);
return "success";
}
@RequestMapping(value="/delSessionAttributes")
public String delSessionAttributes(SessionStatus status){
System.out.println("getSessionAttributes...");
status.setComplete();
return "success";
}
/*
发送ajax请求
$.ajax({
// 编写json格式，设置属性和值
url:"twoCOntroller/testAjaxForStr",
contentType:"application/json;charset=UTF-8",
data:'{"uname":"uname","password":"123","age":30}',
dataType:"json",
type:"post",
success:function(data){}*
* */
@RequestMapping("/testAjax")
//ajax请求然后拿到请求体，然后通过三个jackson包把请求体封装成javabean
//对象，
//因为ajax想让服务器响应的数据类型是json，又因为请求体是json类型
//那么响应体自然也是json类型，所有只需要再返回类型加上@ResponseBody
//它自动将返回类型转换成json类型
public User testAjax(@RequestBody User user){
ModelAndView av=new ModelAndView();
av.addObject("wangcx","mingzi");
Map<String, Object> map = av.getModel();
String wangcx = (String) map.get("wangcx");
System.out.println(wangcx);
// data:'{"uname":"uname","password":"123","age":30}',
/*
由于是异步请求，无法像表单那样，直接User user
只要name属性名一样就行了，但是这样为null
因为异步请求，无法获取到数据,
public void testAjax(User user){}
* User{uname='null', age=0, acount=null}
所以异步请求必须用到
//data:'{"uname":"uname","password":"123","age":30}',
System.out.println(string);//----->{"uname":"uname","password":"123","age":30},
@RequestBody String user-->得到的是json形式的字符串,效果如上
@RequestBody User user-->这样的话//data:'{"uname":"uname","password":"123","age":30}',，
只要里面的name名称跟user属性名一样，就可以被封装成User user对象
这个前提必须导入三个jar才行
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.0</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.9.0</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
<version>2.9.0</version>
</dependency>
*/
System.out.println("123465");
System.out.println(user);
//我们想查询数据库得到数据以json形式响应回去
user.setAge(88);
user.setUname("JSON");
user.setPassword("mami");
return user;
/*
* return user;响应回去的是User对象，并不是json形式的数据
* 因此我们想把user对象以json形式响应回去，我们就要用 @ResponseBody注解
* @ResponseBody的意思就是将User对象以json形式响应回去
* public @ResponseBody User testAjax(@RequestBody User user){}
* 也可以将List Map数据以json响应回去,只需要
* public @ResponseBody Map<Object,Object> testAjax(@RequestBody User user){}
* public @ResponseBody List testAjax(@RequestBody User user){}
* 必须条件就是导入三个jackson包就可以了，
*
* 同理@RequestBody User user，将请求体转换成对象，再表单提交中，不要@RequestBody也能自动转换
* 但是再异步请求中必须需要@RequestBody
* @RequestBody String user，将请求头转换成字符串
* */
}
@RequestMapping("/testAjaxForStr")
public void testAjaxForStr(@RequestBody String user){
//data:'{"uname":"uname","password":"123","age":30}',
System.out.println("123465");
System.out.println(user);//----->{"uname":"uname","password":"123","age":30},
/*异步请求无法做到跟表单一样直接封装成（User user）
所以异步请求必须用到
//data:'{"uname":"uname","password":"123","age":30}',
System.out.println(string);//----->{"uname":"uname","password":"123","age":30},
@RequestBody String user-->得到的是json形式的字符串,效果如上
@RequestBody User user-->这样的话//data:'{"uname":"uname","password":"123","age":30}',，
只要里面的name名称跟user属性名一样，就可以被封装成User user对象
这个前提必须导入三个jar才行
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.0</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.9.0</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
<version>2.9.0</version>
</dependency>
*/
}
}
/*
@RequestMapping("/testString")
public String testString(Model model){
System.out.println("testString方法执行了...");
// 模拟从数据库中查询出User对象
User user = new User();
user.setUsername("美美");
user.setPassword("123");
user.setAge(30);
// model对象
model.addAttribute("user",user);
return "success";
}
@RequestMapping("/testVoid")
public void testVoid(HttpServletRequest request, HttpServletResponse response) throws Exception {
System.out.println("testVoid方法执行了...");
// 编写请求转发的程序
// request.getRequestDispatcher("/WEB-INF/pages/success.jsp").forward(request,response);
// 重定向
// response.sendRedirect(request.getContextPath()+"/index.jsp");
// 设置中文乱码
response.setCharacterEncoding("UTF-8");
response.setContentType("text/html;charset=UTF-8");
// 直接会进行响应
response.getWriter().print("你好");
return;
}
@RequestMapping("/testModelAndView")
public ModelAndView testModelAndView(){
// 创建ModelAndView对象
ModelAndView mv = new ModelAndView();
System.out.println("testModelAndView方法执行了...");
// 模拟从数据库中查询出User对象
User user = new User();
user.setUsername("小凤");
user.setPassword("456");
user.setAge(30);
// 把user对象存储到mv对象中，也会把user对象存入到request对象
mv.addObject("user",user);
// 跳转到哪个页面
mv.setViewName("success");
return mv;
}
@RequestMapping("/testForwardOrRedirect")
public String testForwardOrRedirect(){
System.out.println("testForwardOrRedirect方法执行了...");
// 请求的转发
// return "forward:/WEB-INF/pages/success.jsp";
// 重定向
return "redirect:/index.jsp";
}
@RequestMapping("/testAjax")
public @ResponseBody User testAjax(@RequestBody User user){
System.out.println("testAjax方法执行了...");
// 客户端发送ajax的请求，传的是json字符串，后端把json字符串封装到user对象中
System.out.println(user);
// 做响应，模拟查询数据库
user.setUsername("haha");
user.setAge(40);
// 做响应
return user;
}
*/
<!--
1. 入门案例的执行流程
1. 当启动Tomcat服务器的时候，因为配置了load-on-startup标签，所以会创建DispatcherServlet对象，
就会加载springmvc.xml配置文件
2. 开启了注解扫描，那么HelloController对象就会被创建
3. 从index.jsp发送请求，请求会先到达DispatcherServlet核心控制器，根据配置@RequestMapping注解
找到执行的具体方法
4. 根据执行方法的返回值，再根据配置的视图解析器，去指定的目录下查找指定名称的JSP文件
-->
<context:component-scan base-package="com.sise"></context:component-scan>
<bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/pages/"></property>
<property name="suffix" value=".jsp"></property>
</bean>
<mvc:resources location="/css/" mapping="/css/**"/>
<mvc:resources location="/images/" mapping="/images/**"/>
<mvc:resources location="/js/" mapping="/js/**"/>
<!--配置文件解析器
该解析器配置的id的名字必须是multipartResolver
必须是这个，记住
-->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
<property name="maxUploadSize" value="12514521"></property>
</bean>
<mvc:annotation-driven></mvc:annotation-driven>
</beans>
版权声明：未标注转载均为本站原创，转载时请以链接形式注明文章出处。如有侵权、不妥之处，请联系站长删除。敬请谅解！
常见资源合集和破解 fmvvvteih...