SpringMVC运行性能远大于Struts2,Struts2运行效率低是由于它的ognl和值栈导致的,当然不是说Struts2不优秀,它的拦截器思想还是非常不错的。做网站的话用springMVC比较合适,它的开发效率和Struts2差不多,运行效率比Struts2高。在spring中用注解非常方便,但是Struts2中的注解没那么好用。
一
SpringMVC+hibernate+Spring实例(基于XML)
1.建立项目
拷spring和hibernate的jar包:
spring.jar spring-webmvc.jar commons-logging.jar + hibernate的jar包 新出现了spring-webmvc.jar包,具体包如下
antlr-2.7.6.jar asm-2.2.3.jar asm-commons-2.2.3.jar asm-util-2.2.3.jar aspectjrt.jar aspectjweaver.jar cglib-nodep-2.1_3.jar commons-collections-2.1.1.jar commons-dbcp.jar commons-fileupload.jar commons-io.jar commons-logging.jar commons-pool.jar dom4j-1.6.1.jar ejb3-persistence.jar hibernate-annotations.jar hibernate-commons-annotations.jar hibernate3.jar javassist.jar jta.jar log4j-1.2.11.jar mysql-connector-java-5.1.8-bin.jar spring-webmvc.jar spring.jar |
2.改web.xml配置文件
和Struts2一样,SpringMVC需要在web.xml配置servlet前置控制器(servlet 和 servlet-mapping),项目启动就调用它,初始化springMVC
<servlet>
<servlet-name>dispatcherServlet</servlet-name>
<servlet-class>
org.springframework.web.servlet.DispatcherServlet
</servlet-class>
<init-param> <!-- 初始化一些spring的配置文件 -->
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/hib-config.xml,/WEB-INF/web-config.xml,/WEB-INF/service-config.xml,/WEB-INF/dao-config.xml</param-value>
<!-- 这些配置是可以放在一个配置文件中的,但是会乱,就分到不同的配置文件中。hib-config.xml配置hibernate,
web-config.xml相当于struts2中的struts.xml,是个控制器,service-config.xml配置service层的bean,dao-config.xml配置dao类 -->
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dispatcherServlet</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
3.分别添加前置控制器中的配置文件
配置文件都放WEB-INF下,这是使用SpringMVC的习惯
web-config.xml
包含springmvc的controller(也就是struts2中的action)的相关配置
<?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-2.5.xsd">
<!-- Controller方法调用规则定义 默认的,粘过来不要改动 -->
<bean id="paraMethodResolver" class="org.springframework.web.servlet.mvc.multiaction.ParameterMethodNameResolver">
<property name="paramName" value="action"/>
<property name="defaultMethodName" value="list"/>
</bean>
<!-- 页面View层基本信息设定 -->
<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
<!--<property name="prefix" value="/myjsp/"/> prefix定义前缀为/myjsp/,如果返回一个字符串a,结果会是/myjsp/a-->
<property name="suffix" value=".jsp"/>
<!-- suffix定义后缀为.jsp,如果返回一个a的字符串,那么返回的会是a.jsp -->
</bean>
上面两部分直接拷贝,因为不常改动,下面的很重要,需要手动配置
<!-- servlet映射列表,所有控制层Controller的servlet在这里定义 -->
<bean id="urlMapping"
class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
<property name="mappings">
<props>
<prop key="user.do">userController</prop> <!-- 这里把userController配置成user.do,访问时一定要访问user.do -->
</props>
</property>
</bean>
<bean id="userController" class="com.sxt.action.UserController"> <!-- 上面user.do的具体路径 -->
<property name="userService" ref="userService"></property> <!-- 这是userController中的属性 -->
</bean>
</beans>
hib-config.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:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd">
<context:component-scan base-package="com.sxt"/> <!--基本的组件扫描包-->
<aop:aspectj-autoproxy /><!-- 支持aop注解 -->
<!--数据源-->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
<property name="url" value="jdbc:mysql://localhost:3306/myhib"></property>
<property name="username" value="root"></property>
<property name="password" value="1234"></property>
</bean>
<!--数据连接工厂-->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
<property name="dataSource">
<ref bean="dataSource" />
</property>
<property name="hibernateProperties">
<props>
<!-- key的名字前面都要加hibernate. -->
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.hbm2ddl.auto">update</prop>
</props>
</property>
<property name="packagesToScan">
<value>com.sxt.po</value> <!--实体类位于这个包里-->
</property>
</bean>
<!--hibernate模板类-->
<bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate" >
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
<!--配置一个JdbcTemplate实例-->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"/>
</bean>
<!-- 配置事务管理 -->
<bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager" >
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
<tx:annotation-driven transaction-manager="txManager" />
<aop:config>
<!--com.sxt.service.impl下的所有类的所有方法-->
<aop:pointcut expression="execution(public * com.sxt.service.impl.*.*(..))" id="businessService"/>
<aop:advisor advice-ref="txAdvice" pointcut-ref="businessService" />
</aop:config>
<tx:advice id="txAdvice" transaction-manager="txManager" >
<tx:attributes>
<tx:method name="find*" read-only="true" propagation="NOT_SUPPORTED" />
<!-- get开头的方法不需要在事务中运行 。有些情况是没有必要使用事务的,比如获取数据。开启事务本身对性能是有一定的影响的-->
<tx:method name="*"/> <!-- 其他方法在实务中运行 -->
</tx:attributes>
</tx:advice>
</beans>
dao-config.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-2.5.xsd">
<bean id="userDao" class="com.bjsxt.dao.UserDao">
<property name="hibernateTemplate" ref="hibernateTemplate"></property>
</bean>
</beans>
service-config.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-2.5.xsd">
<bean id="userService" class="com.bjsxt.service.UserService">
<property name="userDao" ref="userDao"></property>
</bean>
</beans>
这些配置文件的目的是把UserController和UserService和UserDao的关系都写在配置文件中,而不是像以前:
UserService us = new UserService();
us.add(); //或us.其它方法,调用us类的哪个方法。
这个步骤已经移到配置文件中了,类只是类,这是解耦,类里只要通过set方法注入,把你要用的类写成属性,并set、get,然后在配置文件中property它。这种设计太妙了!
4.以前用Struts2时包名会起action,现在用SpringMVC包名一般叫controller,类名也叫UserController,而不叫UserAction
UserController.java
public class UserController implements Controller { //Struts2实现Action接口后需要实现它的execute方法,而springmvc实现Controller接口后需要实现ModelAndView方法
private UserService userService;
public ModelAndView handleRequest(HttpServletRequest req,HttpServletResponse resp)throws Exception{
System.out.println("HelloController.handleRequest()");
req.setAttribute("a","aaaa");
userService.add(req.getParameter("uname")); //把你前台提交的uname传递到了userService
return new ModelAndView("index"); //包含在ModelAndView中,ModelAndView类包含了数据和显示,意味着返回的这个ModelAndView类里有setAttribute中的a的数据,也包含了index的视图。在spring mvc配置文件里加了后缀.jsp,所以不用写index.jsp,写index即可。
}
//Spring mvc返回的字符串不用在配置文件中配置才能跳转,而struts2需要到struts.xml中配置,springmvc直接返回就能跳到相关页面
public UserService getUserService(){
return userService;
}
public void setUserService(UserService userService){
this.userService = userService;
}
}
UserDao.java
public class UserDao {
private HibernateTemplate hibernateTemplate;
public void add(User u){
System.out.println("UserDao.add()");
hibernateTemplate.save(u);
}
public HibernateTemplate getHibernateTemplate() {
return hibernateTemplate;
}
public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
this.hibernateTemplate = hibernateTemplate;
}
}
User.java
@Entity
public class User {
@Id
@GeneratedValue(strategy=GenerationType.AUTO)
private int id;
private String uname;
public String getUname() {
return uname;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public void setUname(String uname) {
this.uname = uname;
}
}
UserService.java
public class UserService {
private UserDao userDao;
public void add(String uname){
System.out.println("UserService.add()");
User u = new User();
u.setUname(uname);
userDao.add(u);
}
public UserDao getUserDao() {
return userDao;
}
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
}
5.测试http://locahost:8080/springmvc01/user.do?uname=zhangsan(hib-config.xml要配置对,注意datasource的路径,po中设置了@Entity,所以事先要把数据库中同名的表删掉再测试)
6.看数据库中有没有添加数据zhangsan
题外*************************
访问完连接,连接地址没变,说明是请求转发!!
Struts2用的是ognl表达式,这个不好用,springMVC中用el表达式+jstl就可以了。
***************************************
二
SpringMVC+hibernate+Spring实例(基于ANNOTATION)
上面的实例是基于XML的,现在用注解把它实现一遍
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5"
xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
<servlet>
<servlet-name>dispatcherServlet</servlet-name>
<servlet-class>
org.springframework.web.servlet.DispatcherServlet
</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/hib-config.xml,/WEB-INF/springmvc-servlet.xml</param-value> <!-- 这里的配置不太一样,并且这个示例只配置了hibernate和springmvcController配置文件,其它的都用注解实现了 -->
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dispatcherServlet</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>
hib-config.xml依然放在WEB-INF下,内容和上一个用XML实现的示例的完全一样,所以从上面拷贝
springmvc-servlet.xml
也放在WEB-INF下,这个配置是上面的web-config.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:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd">
<!-- 对web包中的所有类进行扫描,以完成Bean创建和自动依赖注入的功能 -->
<context:component-scan base-package="com.bjsxt"/>
<!-- 启动Spring MVC的注解功能,完成请求和注解POJO的映射 -->
<bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"/>
<!--对模型视图名称的解析,即在模型视图名称添加前后缀 -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
p:suffix=".jsp"/> <!-- 返回a的时候, 后面加.jsp ,加了前缀p:prefix="/WEB-INF/jsp/"会在a的前面加/WEB-INF/jsp/ ,前缀可以不加-->
</beans>
4.相关的类
UserController.java
@Controller("userController") //用component也可以
@RequestMapping("/user.do") //当请求是user.do的时候,这个请求就会跑到当前这个类里面,太简洁了!
public class UserController {
@Resource //注入UserService(把UserController和UserService建立关系)
private UserService userService;
@RequestMapping(params="method=reg") //当访问user.do时,后面携带了method=reg参数时,访问此方法,别的方法也是这样区别
public String reg(String uname){ //Struts中如果要传uname需要写 user的set、get方法,而springmvc中不用,用形参的方式即能传值,形参名和jsp页面的保持一致就可以了,不用写set、get方法,类里简洁多了,还是springmvc好。。。
System.out.println("UserController.reg()");
userService.add(uname);
return "index";
}
public UserService getUserService() {
return userService;
}
public void setUserService(UserService userService) {
this.userService = userService;
}
}
User.java
@Entity
public class User {
@Id
@GeneratedValue(strategy=GenerationType.AUTO)
private int id;
private String uname;
public String getUname() {
return uname;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public void setUname(String uname) {
this.uname = uname;
}
}
UserDao.java
@Repository("userDao")
public class UserDao {
@Resource
private HibernateTemplate hibernateTemplate;
public void add(User u){
System.out.println("UserDao.add()");
hibernateTemplate.save(u);
}
public HibernateTemplate getHibernateTemplate() {
return hibernateTemplate;
}
public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
this.hibernateTemplate = hibernateTemplate;
}
}
UserService.java
@Service("userService")
public class UserService {
@Resource
private UserDao userDao;
public void add(String uname){
System.out.println("UserService.add()");
User u = new User();
u.setUname(uname);
userDao.add(u);
}
public UserDao getUserDao() {
return userDao;
}
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
}
reg.jsp
<body>
<form action="user.do">
用户名:<input type="text" name="uname" /><br/> <!--直接访问到userController了,名字要和userController中的一致,Controller中不用写user的set、get方法了-->
<input type="hidden" name="method" value="reg" /> <!--找到userController中的reg方法-->
<input type ="submit" value="注册" />
</form>
</body>
5.运行测试:
http://pc-201110291327:8080/springmvc02/user.do?method=reg&uname=gaoqi
成功则会调用userController的reg方法,从而将数据内容插入到数据库中。
************************************
用注解注入(建立对象的关系)很简单,在类名上加@Component,在属性(把要建立关系的另一个类作为属性)加上@Resource,就能够啦!
在Controller类(以前的action类)头上需要多写@RequestMapping("/user.do"),相当于之前的servlet的mapping
Controller中的方法前加@RequestMapping(params="method=reg"),相当于servlet中的根据参数分发到方法
*************************************************
三
基于Spring3.0注解项目开发,上面实例是基于2.5的注解
1.拷贝jar包,和之前拷贝不一样!!要全部改成如下图的jar包
2.WEB-INF下Springmvc-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:p="http://www.springframework.org/schema/p"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:util="http://www.springframework.org/schema/util"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.0.xsd">
<!-- 对web包中的所有类进行扫描,以完成Bean创建和自动依赖注入的功能 -->
<context:component-scan base-package="com.bjsxt"/>
<mvc:annotation-driven /> <!-- 支持spring3.0新的mvc注解 -->
<!-- 启动Spring MVC的注解功能,完成请求和注解POJO的映射 -->
<bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"/>
<!--对模型视图名称的解析,即在模型视图名称添加前后缀 -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
p:prefix="/WEB-INF/jsp/" p:suffix=".jsp">
<!-- 如果使用jstl的话,配置下面的属性 -->
<property name="viewClass" value="org.springframework.web.servlet.view.JstlView" />
</bean>
</beans>
3.改完就行了,直接运行,在做项目时,如果要把2.5版本的springmvc改成3.0,也改这两处就行了:1.jar包 2.配置
测试访问reg.jsp,看数据库中添加了没
使用部分已经讲完,就是这么简单********************************************************************************
四
Spring MVC3.0深入,内部实现机制
了解,学技术主要是会用,原理可以后边慢慢理解,到公司没人总拿原理来考你
核心原理对在springmvc的2.0或是3.0是一样的,没区别
当客户端发送请求后,spring内部是怎么处理的??
1.当用户发送请求给服务器:url:user.do
2.发现DispatchServlet可以处理,于是调用DispatchServlet (web.xml中配置的前置控制器)
3.通过HandleMapping检查这个url有没有对应的Controller,如果有,就调用(在源码中可以找到HandleMapping)
4.自己的控制器开始执行
5.执行完毕后,如果返回的是字符串,则ViewResolver将字符串转化成相应的视图对象,如果返回的是ModelAndView对象,它两是ModelAndView对象的两个属性,分别负责ModelAndView对象的视图和数据的信息
6.DispatchServlet将视图对象中的数据,输出给服务器
7.服务器将数据输出给客户端
springmvc中重要的类
ModelAndView对象,里面两个属性,一个model和一个view
ViewResolver对象,只包含视图信息
DispatchServlet对象,继承自HttpServlet
HandletMapping对象,匹配url和control,是总控制器
Spring相关注解的用法!!!
@Controller控制器定义
用它和用@Component是等价的,只不过一看@Controller就知道是控制器(Controller层=struts2中的action层)
不管用哪个,它们的作用中是让Spring知道它是个bean就行了。
Spring中的@Controller是单例的,意味着它会被多个请求共享,所以才能实现数据共享,因此它是无状态的。所以jsp页面传递值到Controller时不用属性注入,而是利用形参,因为形参是每个方法一份的,不会共享导致脏数据。
**为使Spring能找到定义为Controller的bean,需要在Spring-context配置文件中增加“组件扫描":
<context:component-scan base-package="com.bjsxt.web" />
@RequestMapping
在类前面定义,则将url和类绑定
在方法前面定义,则将url和类的方法绑定
@RequestMapping("/user.do") //当访问user.do时会访问到UserController类
public class UserController{ }
@RequestMapping(params="method=reg") //当要访问某个方法时,RequestMapping需要携带某个参数,根据参数调用方法
public String reg(String uname){ }
@RequestParam
用在jsp页面要传的值和Controller获取的值不同名时,如
reg.jsp
<form action="user.do">
用户名:<input type="text" name="uname" /></br>
<input type="hidden" name= "method" value="reg3" /> <!--指向reg3方法-->
<input type="submit" value="注册" />
</form>
UserController.java
@RequestMapping(params="method=reg3")
public String reg3(@RequestParam("uname")String name){ //名称不匹配,用RequestParam告诉形参,jsp页面的参数名叫uname
System.out.pringln(name);
userService.add(name);
return "index";
}
一般名字都一样
**************************
ModelMap
它是个Map,可以在其中存放值,它的值默认是放在request的作用域中的,示例如下
UserController.java
@RequestMapping(params="method=reg3)
public String reg3(@RequestParam("uname")String name,ModelMap map){ //加了ModelMap map,Sping mvc会自动创建ModelMap
System.out.println("name");
map.put("a","aaa"); //这样使用ModelMap,把值放到了ModelMap中,相当于放到了request作用域中,取的时候要在jsp页面${requestScope.a}
return "index";
}
UserController.java
@RequestMapping(params="method=reg3")
public String reg3(@RequestParam("uname") String name,HttpServletRequest req){ //需要什么就在形参里定义什么,Spring会自动帮你new,你只管用,太方便了!这个示例里你能用传来的参和request
System.out.println(name);
userService.add(name);
return "index";
}
**************************************************************
@SessionAttribute这个一般放在类前面,意味着整个类的ModelMap放入值,session作用域都能取到,不管在哪个方法存入的。(这是个奇特的东西,还是很有作用嘀)
操作Session,将ModelMap中指定的属性放到session中
ModelMap的值默认是放到request作用域中的,下面示例演示了怎样将值放在session中
@Controller
@RequestMapping("/user.do")
@SessionAttributes({"u","a"}) //类前定义了它,会将ModelMap中属性名字为u、a的值”再“放入session作用域中,这样,request和session中都有了u和a的值
public class UserController{
@RequestMapping(params="method=reg4")
public String reg4(ModelMap map){ //这里定义ModelMap
System.out.println("HelloController.handleRequest()");
map.addAttribute("u","uuu"); //由于上面定义了SessionAttributes,存入值的时候同时也把值放入了session里面
map.put("a","aaa"); //put和addAttribute的作用一样
return "index";
}
}
SessionAttributes的作用是request中和session中都有ModelMap的值,ModelMap的值默认放在request作用域中。
@ModelAttribute
跟@SessionAttributes配合一起使用,将ModelMap中属性的值通过该注解自动”赋给指定变量“
假如你的类有两个方法,第一个方法已经取过一次值了,并且放到了session里面(注意,必须是放到了session里面),第二个方法可以不用根据形参再去前台获取值,而是获取上一个方法获得到的值”并赋给指定变量!“
示例代码
@RequestMapping(params="method=reg5")
public String reg5(@ModelAttribute("u") String u) { //从session中取u的值,赋给后面的String u
System.out.println("aaaaaaaaaaa");
return "index";
}
springmvc的获取对象和返回值
*Controller类里方法的参数的处理。。直接往里放就得了,Spring mvc会帮你new
*Controller类里方法返回值的处理。。一般返回String,返回String是由ModelAndView处理。也可以返回ModelMap、ModelAndView对象、map、List、set、object、无返回值,但是都不推荐,推荐返回字符串
*获得request对象、session对象。。获得request对象在形参中直接声明
public String reg2(String uname,HttpServletRequest req){ } //这样就能用req了,response对象也直接声明
session对象是在类上面加@SessionAttribute,来获取requesst中的值
************************************
请求转发和重定向
springmvc默认转发,要重定向,return的时候这样写:return "redirect: http://www.baidu.com" 加redirect是重定向,重定向可以定向到任何地方
转发可以写return "forward:user.do?method=reg5"; 当然不写默认也是转发
****************************************
ModelAndView模型视图类
示例(视图、模型分开存放,因为ModelAndView类中有两个属性,分别就是存放视图和模型的)
public ModelAndView reg(String uname){
ModelAndView mv = new ModelAndView();
mv.setViewName("index"); //ModelAndView对象中放入视图
User u = new User();
u.setUname("小高");
mv.addObject(u); //可以直接把u放入mv,而不指定u的名字,名字会默认为u代表的类的名字首字母小写,也就是user,相当于mv.addObject("user",u);
mv.addObject("a","aaa");//一般要指定属性的名字的,这些值都默认放在ModelMap中了,ModelMap是很重要的,不用sessionAttribute的话ModelMap的值都在request中放着,所以用request读取
return mv;
}
下面是比较实用的部分*******************************************
SpringMVC3.0的文件上传实现
1.springmvc和struts2一样,也是使用apache-commons-fileupload.jar和apache-commons-io.jar这两个组件,因此我们需要引入这两个jar包
2.在springmvc-servlet.xml配置文件中,增加CommonsMultipartResoler配置,增加了一个multipartResolver的bean,它专门用来处理上传的
<!--处理文件上传-->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver" >
<property name="defaultEncoding" value="gbk"/> <!-- 默认编码 (ISO-8859-1) -->
<property name="maxInMemorySize" value="10240"/> <!-- 最大内存大小 (10240)-->
<property name="uploadTempDir" value="/upload/"/>
<property name="maxUploadSize" value="-1"/> <!-- 最大文件大小,-1为无限止(-1) -->
</bean>
**uploadTempDir是上传后的目录名,在项目中建立一个upload文件夹 ,这只是临时路径,本地路径在Controller中this.servletContext.getRealPath("/tmp/")定义着。这里如 果达到上面定义的大小(10240)后,再存入硬盘上。这不是最终存放路径。另外开发目录下也要有/tmp/文件夹
这个直接粘过来
3.建立upload.jsp页面
<%@ page language="java" import="java.util.*" pageEncoding="gbk" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>测试springmvc中上传的实现</title>
</head>
<body>
<form action="upload.do" method="post" enctype="multipart/form-data"> <!--如果做上传,emthod和enctype的参数是固定的这两个,不能变!!-->
<input type="text" name="name" />
<input type="file" name="file" />
<input type="submit" />
</form>
</body>
</html>
4.建立控制器FileUploadController.java
@Controller
public class FileUploadController implements ServletContextAware {//实现上传功能要实现ServletContextAware这个类
private ServletContext servletContext;//在springmvc中获取servletContext对象,需要实现ServletContextAware接口,写个属性,实现set方法通过spring注入进来
public void setServletContext(ServletContext servletContext){
this.servletContext = servletContext;
}
@RequestMapping(value="/upload.do",method=RequestMethod.POST) //method=RequestMethod.POST,加了这个,只有请求方式为post,请求才能到这里,不然到不了。所以必须是post请求。value="/upload.do",没放在类前,而是放在方法前,那么在访问upload.do时直接访问到这个方法。
public String handleUploadData(String name,@RequestParam("file") CommonsMultipartFile file) { //handleUploadData处理上传数据 name和file对应前台表单的name和file,本来名字对应可以不写@RequestParam(),但是文件上传,名字对应了也得写!!
if( ! file.isEmpty()){//不为空,有内容,存到本地服务器
String path = this.servletContext.getRealPath("/tmp/"); //获取本地存储路径servletContext是指属性的servletContext servlet上下文对象
System.out.println(path);
String fileName = file.getOriginalFilename(); //这获取的是上传时的名字,如奥运会.avi
String fileType = fileName.substring(fileName.lastIndexOf(".")); //从后数第一个点,这是获取类型
System.out.println(fileType);
File file2 = new File(path,new Date().getTime()+fileType); //新建一个文件,括号里是文件名定义规则。第一个参数是放在哪,新文件名叫path变量+当前时间+文件类型
try{
file.getFileItem().write(file2); //将上传的文件写入新建的文件中,内部是一个输入流和输出流的对口
} catch (Exception e) {
e.printStackTrace();
}
return "redirect : upload_ok.jsp"; //重定向
}else {
return "redirect : upload_error.jsp";
}
}
}
5.upload_ok.jsp
<%@ page language="java" import="java.util.*" pageEncoding="gbk" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<body><h3>上传成功!</h3></body>
</html>
6.upload_err.jsp
<%@ page language="java" import="java.util.*" pageEncoding="gbk" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" >
<html>
<body><h3>上传失败!</h3></body>
</html>
文件上传end***********************************************************************
Spring3.0处理ajax请求
Spring使用了jackson类库,它可以把json数据转换成java对象,也可以把java对象转化为json数据。很多框架都使用了jackson类库。
1.导入几个jar包
jackson-core-asl-1.7.2.jar
jackson-mapper-asl-1.7.2.jar
2.SpringMVC配置文件springmvc-servlet.xml中增加
<mvc:annotation-driven /> <!-- 支持spring3.0新的mvc注解 -->
<!-- 启动Spring MVC的注解功能,完成请求和注解POJO的映射 -->
<bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
<property name="cacheSeconds" value="0" />
<property name="messageConverters">
<list>
<bean class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter"></bean>
</list>
</property>
</bean>
3.客户端写testAjax.jsp页面,用的是原始的ajax请求
<%@ page language="java" import="java.util.*" pageEncoding="gbk"%>
<%String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/"; %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<base href="<%=basePath%>">
<title>My JSP 'testAjax.jsp' starting page</title>
<script type="text/javascript">
function createAjaxObj(){
var req;
if(window.XMLHttpRequest){
req = new XMLHttpRequest();
}else {
req = new ActiveXObject("Msxml2.XMLHTTP"); //ie
}
return req;
}
function sendAjaxReq(){
var req = createAjaxObj();
req.open("get","myajax.do?method=test1&uname=张三&a="+Math.random());//加随机数避免缓存,小技巧,这样每次url都不一样。
req.setRequestHeader("accept","application/json"); //这句一定要加!!!不加这个请求头,spring分不出这是个ajax请求。spring分出这是个ajax请求后,然后跳到myajax.do中
req.onreadystatechange = function(){
eval("var result="+req.responseText); //responseText是返回的数据
document.getElementById("div1").innerHTML = result[0].uname;//返回的result是数组,把数组0中的数据放到div1中
}
req.send(null);
}
</script>
</head>
<body>
<a href="javascript:void(0);" οnclick="sendAjaxReq();">测试</a>
<div id="div1"></div>
</body>
</html>
4.服务器端代码如下
@Controller
@RequestMapping("myajax.do")
public class MyAjaxController {
@RequestMapping(params="method=test1",method=RequestMethod.GET)
public @ResponseBody List<User> test1(String uname) throws Exception {//如果处理的是ajax请求的话,要在方法修饰符加一个@ResponseBody,说明了这是一个ajax请求。返回的List还可以是User、String,这些对象spring会帮你把这些java对象转换成json的数组、json对象等等,自动转换,不需要你管。uname是前台传入的。
String uname2 = new String(uname.getBytes("iso8859-1"),"gbk"); //解决中文
System.out.println(uname2);
System.out.println("MyAjaxController.test1()");
List<User> list = new ArrayList<User>();//new了个list
list.add(new User("高淇","123"));
list.add(new User("马士兵","345"));
return list; //把这个list对象返回到前台。list到前台是一个数组
}
}
5.测试访问http://localhost:8080/项目名/testAjax.jsp
以后写ajax很方便了,不需要dwr了,springmvc已经有了!!!
springmvc处理ajax请求end******************************************************
String MVC中的拦截器
借鉴了Struts2中的拦截器思想,但是要比Struts2中的好用,用来拦截Spring中的相关请求
Spring拦截器实现的两种方式:
1.实现接口:org.springframework.web.servlet.HandlerInterceptor
2.继承一个适配器:org.springframework.web.servlet.handler.HandlerInterceptorAdapter,继承了它,想用它的方法可以用它的,不想用可以自己写自己的实现,这是继承的好处,而接口不想用,你也得实现接口中的方法
这两种方法都可以。
接口实现拦截器示例
public class MyInterceptor implements HandlerInterceptor{
@Override
public void afterCompletion ( HttpServletRequest request , HttpServletResponse response , Object handler , Exception ex) throws Exception { //释放资源或是处理异常
System.out.println("最后执行!!!一般用于释放资源!!");
}
@Override
public void postHandle(HttpServletRequest request , HttpServletResponse response , Object handler , ModelAndView modelAndView) throws Exception { //postHandle是在action执行之后 ,生成视图之前执行。
System.out.println("Action执行之后,生成视图之前执行!!");
}
@Override
public boolean preHandle(HttpServletRequest request , HttpServletResponse response , Object handler ) throws Exception {//preHandle这个方法是在action之前执行,preHandle是用的最多的!!!这个类里的方法不一定都要写具体实现,只是实现了接口,所以实现一些空方法,你用哪个方法就实现哪个方法,这个方法可以在action执行之前对request、response、handler进行操作,因为参数里定义了,就可以随便操作了。
System.out.println("action之前执行!!");
return true;//继续执行action,return false,保持不动了,不再往下执行。当然也可以重定向到别处:request.getRequestDispatcher("index.jsp").forward(request,response);
}
}
适配器实现拦截器示例
public class MyInterceptor2 extends HandlerInterceptorAdapter {
@Override
public boolean preHandle(HttpServletRequest request , HttpServletResponse response , Object handler) throws Exception {
System.out.println("MyInterceptor2.preHandle()");
return true; //继续执行action ,false不执行action
}
}
不管是哪种拦截器,都需要配置xml配置文件
<mvc:interceptors> <!--可以定义多个拦截请求,这和配置servlet差不多-->
<bean class="com.bjsxt.interceptor.MyInterceptor"></bean> <!--拦截所有springmvc的url! 可以只写一个bean-->
<mvc:interceptor>
<mvc:mapping path="/user.do" /> <!--拦截指定请求-->
<mvc:mapping path="/user2.do" /> <!--拦截指定请求-->
<!--<mvc:mapping path="/test/*" />--> <!--拦截test/*-->
<bean class="com.sxt.interceptor.MyInterceptor2"></bean>
</mvc:interceptor>
</mvc:interceptors>