spring是什么？
- 是一个开源的用来简化应用开发的框架。
简化开发
spring对常用的api进行了封装和简化
- 比如，对jdbc做了封装，使用spring jdbc来访问数据库，就不需要考虑获取连接和关闭连接了
管理对象
- spring提供了一个容器，帮我们创建以及建立对象之间的依赖关系。
- 这样做的好处是，降低对象之间的耦合度，方便代码的维护。
集成其他框架
- spring可以将其他的一些框架集成进来
- 比如，集成用于任务调试的框架Quartz，即“不发明重复的轮子”。
一站式的框架
spring容器
- spring容器是什么？
spring框架中的一个核心模块，用于管理对象。
- 启动spring容器
1.导包 spring-webmvc
2.添加配置文件
3.启动spring容器
如何创建对象？
方式一：使用无参构造器（重点）
1.给类添加无参构造器（或者缺省构造器）
2.配置<bean>元素
3.调用容器的getBean方法获得对象。
方式二：使用静态工厂方法
通过调用类的静态方法来创建对象。
方式三：使用实例工厂方法
通过调用对象的实例方法来创建对象。
作用域
- 默认情况下，容器对于某个bean，只会创建一个实例。
- 可以设置scope属性值为prototype，这样，容器对于某个bean会创建多个实例。
生命周期
- 初始化 分配资源
初始化方法：使用init-method属性来指定初始化方法名。
注：spring容器创建对象之后，会立即调用初始化方法。
- 销毁 释放资源
销毁方法：使用destroy-method属性来指定销毁方法名。
注：spring容器在关闭之前，会先销毁对象，在销毁对象之前，会先调用对象的销毁方法。
只有作用域为单例时，销毁方法才会执行。
延迟加载
spring容器启动之后，会将所有作用域为单例的bean创建好。
指定lazy-init属性值为true，此时，spring容器对于作用域为单例的bean，
就不会创建相应的实例了。
首先呢，还是导包，导入sprint-webmvc和junit
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>3.2.8.RELEASE</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
</dependencies>
ApplicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:beans="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:jdbc="http://www.springframework.org/schema/jdbc"
xmlns:jee="http://www.springframework.org/schema/jee"
xmlns:jms="http://www.springframework.org/schema/jms"
xmlns:lang="http://www.springframework.org/schema/lang"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:tx="http://www.springframework.org/schema/tx"
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.2.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
http://www.springframework.org/schema/jms http://www.springframework.org/schema/tx/spring-jms-3.2.xsd
http://www.springframework.org/schema/lang http://www.springframework.org/schema/tx/spring-lang-3.2.xsd
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd">
使用无参构造器创建对象。
id属性：bean的名称，要求唯一。
class属性：类的全限定名（即要求包含包名）
<bean id="stu1" class="first.Student" />
<bean id="date" class="java.util.Date" />
使用静态工厂方法创建对象
factory-method属性：指定一个静态方法，
sprint容器会调用这个静态方法来创建对象。
<bean id="cal1" class="java.util.Calendar" factory-method="getInstance" />
使用实例工厂方法创建对象
factory-bean属性：指定一个bean的id，
factory-method属性：指定一个方法，
spring容器会调用这个bean的对应方法来创建对象。
<bean id="time1" factory-bean="cal1" factory-method="getTime" />
scope属性：用来配置作用域，缺省值是singleton（即一个bean只创建一个实例）
如果值为prototype（即一个bean会创建多个实例）
<bean id="s1" class="scope.ScopeBean" scope="prototype"/>
init-method属性：指定初始化方法。
destroy-method属性：指定销毁方法。
lazy-init属性：指定是否延迟加载，如果值为true，表示延迟加载。
<bean id="mb1" class="scope.MessageBean" init-method="init" destroy-method="destroy" lazy-init="true"/>
</beans>
MessageBean
package scope;
public class MessageBean {
public MessageBean() {
System.out.println("MessageBean");
}
public void init() {
System.out.println("init");
}
public void sendMsg() {
System.out.println("sendMsg");
}
public void destroy() {
System.out.println("destroy");
}
}
TestCase.java，使用junit来测试上面编写的代码
package test;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import scope.MessageBean;
import scope.ScopeBean;
public class TestCase {
* 测试作用域
@Test
public void test1() {
ApplicationContext ac = new ClassPathXmlApplicationContext("scope.xml");
ScopeBean s1 = ac.getBean("s1", ScopeBean.class);
ScopeBean s2 = ac.getBean("s1", ScopeBean.class);
System.out.println(s1 == s2);
}
* 测试生命周期
@Test
public void test2() {
* ApplicationContext：接口
* AbstractApplicationContext：其子接口
* ClassPathXmlApplicationContext：实现上面接口的类
AbstractApplicationContext ac = new ClassPathXmlApplicationContext("scope.xml");
MessageBean mb1 = ac.getBean("mb1", MessageBean.class);
mb1.sendMsg();
* 关闭容器
ac.close();
}
@Test
public void test3() {
AbstractApplicationContext ac = new ClassPathXmlApplicationContext("scope.xml");
}
}
IOC（Intersion Of Controll 控制反转）
之前代码中对象之间的依赖关系由对象之间来建立，这样耦合性太强，牵一发而动全身，
而一般情况下我们的java代码是不能修改的。
IOC是什么？
- 对象之间的依赖关系由容器来建立。
DI（Dependency InJection 依赖注入）是什么？
容器通过调用对象提供的set方法或者构造器来建立依赖关系。
注：IOC是目标，DI是手段。
set方式注入：
- 1.提供相应的set方法。
- 2.配置<property>元素。
A类
package ioc;
public class A {
private BC o; * BC是接口
public void setB(BC o) {
System.out.println("A setB");
this.o = o;
}
public A() {
System.out.println("A");
}
public void execute() {
System.out.println("A's execute");
o.f1();
}
}
BC类接口
package ioc;
public interface BC {
public void f1();
}
B类
package ioc;
public class B implements BC{
public B() {
System.out.println("B");
}
public void f1() {
System.out.println("B's f1");
}
}
C类
package ioc;
public class C implements BC{
public C() {
System.out.println("C");
}
public void f1() {
System.out.println("C's f1");
}
}
ioc.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:beans="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:jdbc="http://www.springframework.org/schema/jdbc"
xmlns:jee="http://www.springframework.org/schema/jee"
xmlns:jms="http://www.springframework.org/schema/jms"
xmlns:lang="http://www.springframework.org/schema/lang"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:tx="http://www.springframework.org/schema/tx"
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.2.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
http://www.springframework.org/schema/jms http://www.springframework.org/schema/tx/spring-jms-3.2.xsd
http://www.springframework.org/schema/lang http://www.springframework.org/schema/tx/spring-lang-3.2.xsd
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd">
property元素：表示使用set方法来注入依赖关系。
其中，name属性指定属性名，ref属性指定属性值（是被注入的bean的id）。
默认调用 SetB()
<bean id="a1" class="ioc.A">
<property name="b" ref="c1"/>
</bean>
<bean id="b1" class="ioc.B"/>
<bean id="c1" class="ioc.C"/>
</beans>
调用类
@Test
public void test2() {
ApplicationContext ac = new ClassPathXmlApplicationContext("ioc.xml");
A a1 = ac.getBean("a1", A.class);
a1.execute();
}
打印结果：
A
C
A setB
B
A's execute
C's f1
解释：在ioc.xml文件中可以看到，定义的三个bean的作用域都是单例的（默认是单例），
在容器启动时读取ioc.xml配置文件过程中会自动创建单例对象，所以A，B，C对象都会创建，
各个bean的放置前后位置是没有关系的，spring会自动调用
构造器方式注入
1.添加相应的构造器。
2.配置constructor-arg
<bean id="b1" class="ioc2.B"/>
constructor-arg元素：
用来配置构造器方式的注入，其中index属性指定参数的下标（从0开始)
<bean id="a1" class="ioc2.A">
<constructor-arg index="0" ref="b1"/>
</bean>
注意：b1调用的是有参构造
public A(B b) {
System.out.println("A(B)");
this.b = b;
}
自动装配
自动装配，指的是spring容器依据某种规则，自动建立对象之间的依赖关系。
注意：
a.默认情况下，容器不会自动装配。
b.可以通过指定autowire属性来告诉容器进行自动装配，
容器依然需要通过调用set方法或者构造器来完成依赖关系的建立。
autowire属性：表示让容器自动装配。该属性有如下三个值：
byName：容器依据属性名查找对应的bean，然后调用对应的set方法来完成注入。
注：a.如果找不到对应的bean，注入null
b.不可能找到多个符合条件的bean
byType:容器依据属性类型查找对应的bean，然后调用对应的set方法来完成注入。
注：a.如果找不到对应的bean，注入null
b.有可能找到多个符合条件的bean，此时会出错。
constructor：与byType类似，不同的是调用对应的构造器来完成注入。
<bean id="writer1" class="ioc2.Writer"/>
<bean id="writer2" class="ioc2.Writer"/>
<bean id="restaurant" class="ioc2.Restaurant" autowire="byType"/>
注入基本类型的值
使用value属性即可
被注入的类
package value;
public class ValueBean {
private String name;
private int age;
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public ValueBean() {
System.out.println("ValueBean()");
}
@Override
public String toString() {
return "ValueBean [name="+name+", age="+age+"]";
}
}
<bean id="value" class="value.ValueBean">
<property name="name" value="李白"/>
<property name="age" value="30"/>
</bean>
注入List，Set，Map，Properties等集合类型
1.注入List的值
package value;
import java.util.List;
public class ValueBean {
private List<String> city;
public void setCity(List<String> city) {
this.city = city;
}
@Override
public String toString() {
return "ValueBean [city=" + city + "]";
}
}
<bean id="value" class="value.ValueBean">
<property name="city">
<list>
<value>北京</value>
<value>长沙</value>
<value>杭州</value>
</list>
</property>
</bean>
打印：
ValueBean [city=[北京, 长沙, 杭州]]
2.Set注入
package value;
import java.util.Set;
public class ValueBean {
private Set<String> interests;
public void setInterests(Set<String> interests) {
this.interests = interests;
}
@Override
public String toString() {
return "ValueBean [interests=" + interests + "]";
}
}
<bean id="value" class="value.ValueBean">
<property name="interests">
<set>
<value>盗墓</value>
<value>打架</value>
<value>挖掘机</value>
<value>挖掘机</value>
</set>
</property>
</bean>
打印：
ValueBean [interests=[盗墓, 打架, 挖掘机]] ---相同的值被过滤掉了
3.Map注入
package value;
import java.util.Map;
public class ValueBean {
private Map<String,Double> score;
public void setScore(Map<String, Double> score) {
this.score = score;
}
@Override
public String toString() {
return "ValueBean [score=" + score + "]";
}
}
<bean id="value" class="value.ValueBean">
<property name="score">
<map>
<entry key="Englist" value="60"/>
<entry key="Math" value="88"/>
<entry key="语文" value="66"/>
</map>
</property>
</bean>
打印：
ValueBean [score={Englist=60.0, Math=88.0, 语文=66.0}]
4.Propertiest注入
package value;
import java.util.Properties;
public class ValueBean {
private Properties db;
public void setDb(Properties db) {
this.db = db;
}
@Override
public String toString() {
return "ValueBean [db=" + db + "]";
}
}
<bean id="value" class="value.ValueBean">
<property name="db">
<props>
<prop key="username">Tiger</prop>
<prop key="password">123456</prop>
</props>
</property>
</bean>
打印：
ValueBean [db={password=123456, username=Tiger}]
引用方式注入集合类型的值
<!-- 将集合类型的值配置成一个bean -->
<util:list id="cityBean">
<value>上海</value>
<value>杭州</value>
<value>北京</value>
</util:list>
<!-- 引用的方式注入集合类型的值 -->
<bean id="value" class="value.ValueBean">
<property name="city" ref="cityBean"/>
</bean>
读取properties文件的内容。
classpath：按照类路径来搜索。
spring容器会依据路径找到对应的properties文件，
然后读取该文件的内容到Properties对象。
<util:properties id="config" location="classpath:db.properties"/>
使用spring表达式
可以使用spring表达式读取其他的bean的属性，它的语法类似与EL表达式。
注意：下图中的SpelBean必须要配置有get方法
spring表达式.png
map的两种用法，中文只能使用下面第二种
<property name="score" value="#{some.score.English}"/>
<property name="score" value="#{some.score['语文']}"/>
使用注解简化配置
- 1.什么是组件扫描？
spring容器在启动之后，会扫描该包及其子包下面的所有类，
如果该包前面有特定的注解（比如@component），则spring容器
会将其纳入容器进行管理（相当于配置了一个bean元素）。
注：除了@Component注解，还有@Service，@Repository和@Controller，
作用是等价的，只不过有语义上的差异。
- 2.如何进行组件扫描？
在类前添加特定的注解。
在配置文件中，添加组件扫描的配置。
在配置文件.xml中加上一句配置组件扫描，base-package属性：指定要扫描的包名，
<context:component-scan base-package="annotation"/>
注解 1
注解 2
依赖注入相关的注解
- @Autowired 和 @Qualifier
a.该注解支持set方式注入和构造器方式的注入。
b.当采用set方式注入时，可以将@Autowired添加到set方式前面，
如果不使用@Qualifier，则容器会使用byType的方式来注入，有可能出错，
所以建议使用@Qualifier注解，明确要注入的bean的id。
注：也可以将这两个注解直接添加到属性前
(这样就不会调用类中的set方法，spring用反射调用)
c.当采用构造器注入时，可以将该注解添加到对应的构造器前面即可。
- @Resource (重点)
a.只支持set方式的注入。
b.可以将该注解添加到set方法前，使用name属性指定要注入的bean的id。
（如果不指定，会安装byType的方式注入）
注：也可以将该注解添加属性前。
Qualifier()中的 wt 指的是对应bean的id
private Waiter wt;
@Autowired
public void setWt(@Qualifier("wt") Waiter wt) {
System.out.println("setWt()");
this.wt = wt;
}
也可以这么写
@Autowired
@Qualifier("wt")
private Waiter wt;
public void setWt( Waiter wt) {
System.out.println("setWt()");
this.wt = wt;
}
这种方式注解，spring就不会调用setWt方法了，在底层用反射实现这个功能，
也就是说，连setWt方法都不需要了
4.png
@Value注解
a.可以使用该注解来注入基本类型的值。
b.也可以使用该注解来使用spring表达式。
c.该注解可以添加到属性前，或者添加到对应的set方法前。
package annotation;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
@Component("mg")
public class Manager {
@Value("#{config.pagesize}")
private String pageSize;
@Value("花千骨")
private String name;
@Override
public String toString() {
return "Manager [pageSize=" + pageSize + ", name=" + name + "]";
}
public Manager() {
System.out.println("Manager()");
}
}
<context:component-scan base-package="annotation"/>
<util:properties id="config" location="classpath:config.properties"/>
config.properties文件
pagesize=203
测试类
@Test
public void test4() {
ApplicationContext ac = new ClassPathXmlApplicationContext("annotation.xml");
Manager mg = ac.getBean("mg", Manager.class);
System.out.println(mg);
}
打印结果：
Manager()
Manager [pageSize=203, name=花千骨]
springmvc
springmvc.png
springmvc是什么？
- 是一个mvc框架，用来简化基于mvc架构的web应用开发。
五大组件
- DispatherServlet（前端控制器）:
接受请求，依据HandlerMapping的配置调用相应的模型来处理。
- HandlerMapping：
包含了请求路径与模型的对应关系。
- Controller（处理器）：
负责处理业务逻辑。
- ModelAndView：
封装了处理结果，处理结果除了数据之外，还可能有视图名。
- ViewResolver（视图解析器）：
DispatherServlet依据ViewResolver的解析，
调用真正的视图对象来生成相应的页面。
注：五大组件的关系
a.DispatcherServlet收到请求之后，依据HandlerMapping的配置，调用相应的Controller来处理。
b.Controller将处理结果封装成ModelAndView对象，然后返回给DispatcherServlet。
c.DispatcherServlet依据ViewResolver的解析，调用相应的视图对象（比如某个jsp）来生成相应的页面。
编程步骤
1.导包
2.添加spring配置文件
3.配置DispatcherServlet
4.写Controller（处理器）
5.写jsp
6.在spring配置文件中，添加以下配置：
a.HandlerMapping
b.Controller
c.ViewResolver
springmvc Helloworld项目
hello.png
第一步，导包
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>3.2.8.RELEASE</version>
</dependency>
修改web.xml文件，设置匹配路径
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" version="2.5">
<servlet>
<servlet-name>springmvc</servlet-name>
<servlet-class>
org.springframework.web.servlet.DispatcherServlet
</servlet-class>
DispatcherServlet在初始化方法里面，会读取该初始化参数的值来获取spring配置文件的位置，然后启动spring容器。
<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>springmvc</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
</web-app>
在main的resource文件夹中建立一个springmvc.xml文件，写入下面的内容
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:beans="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:jdbc="http://www.springframework.org/schema/jdbc"
xmlns:jee="http://www.springframework.org/schema/jee"
xmlns:jms="http://www.springframework.org/schema/jms"
xmlns:lang="http://www.springframework.org/schema/lang"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:tx="http://www.springframework.org/schema/tx"
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.2.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
http://www.springframework.org/schema/jms http://www.springframework.org/schema/tx/spring-jms-3.2.xsd
http://www.springframework.org/schema/lang http://www.springframework.org/schema/tx/spring-lang-3.2.xsd
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd">
<!-- 配置HandlerMapping -->
<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
<property name="mappings">
<props>
<prop key="/hello.do">helloController</prop>
</props>
</property>
</bean>
<!-- 配置处理器 -->
<bean id="helloController" class="controller.HelloController"></bean>
<!-- 配置视图解析器 -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/"/>
<property name="suffix" value=".jsp"/>
</bean>
</beans>
配置完之后就要写Controller控制器了
package controller;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;
public class HelloController implements Controller{
public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
System.out.println("handleRequest()");
* ModleAndView有两个构造器：
* 1.ModelAndView(String ViewName)，ViewName是视图名。
* 2.ModelAndView(String ViewName, Map data)，Map用于封装处理结果数据。
return new ModelAndView("hello");
}
}
最后在WEB-INF目录下写一个jsp文件，名称为hello.jsp，命名需要和ModelAndView返回的名称一致。
<%@ page contentType="text/html; charset=utf-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>title</title>
</head>
<body>
<h1>hello springmvc!!!</h1>
</body>
</html>
spring-hello.png
利用spring提供的注解简化上面的helloworld程序
使用注解来开发基于springmvc的web应用
编程步骤：
- 1.导包
- 2.添加spring的配置文件
- 3.配置DispatherServlet
- 4.写Controller
- 5.写jsp
- 6.在spring配置文件中，添加如下配置：
a.组件扫描
b.mvc注解扫描
c.视图解析器
读取请求参数值，
- 1. 通过request对象
注：将request对象作为方法的入参即可。
- 2.使用@RequestParam注解
注：将该注解添加到方法的形参前面。
- 3.使用javabean封装请求参数值
写一个java类，要求属性名与请求参数名一致，并且提供相应的get/set方法。
将该javabean作为方法的形参。
web.xml文件跟上面的一样，jar包也是相同的，不同的是配置文件和Controller方法
springmvc.xml配置文件
<!-- 配置组件扫描 -->
<context:component-scan base-package="controller"/>
<!-- 配置mvc注解扫描 -->
<mvc:annotation-driven/>
<!-- 配置视图解析器 -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/"/>
<property name="suffix" value=".jsp"/>
</bean>
Controller控制器，获取请求参数的四种方式
package controller;
import javax.servlet.http.HttpServletRequest;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
* 如何写一个处理器：
* 1.不用实现Controller接口。
* 2.可以在处理器类中，添加多个方法，每一个方法处理一种类型的请求。
* 3.方法类型不作要求，返回类型可以是ModelAndView，也可以是String
* 4.使用@Controller，将该处理器纳入容器进行管理，
* 也就是说，spring配置文件不用在配置该处理器。
* 5.使用@RequestMapping，告诉前端控制器（DispatcherServlet），
* 请求路径与处理器的方法的对应关系。
* （spring配置文件不用配置HandlerMapping了）
@Controller
public class HelloController {
@RequestMapping("/hello.do")
public String hello() {
System.out.println("hello()");
return "hello";
}
@RequestMapping("/tologin.do")
public String toLogin() {
System.out.println("toLogin()");
return "login";
}
* 读取请求参数值的第一种方法，通过request对象。
@RequestMapping("/login.do")
public String login(HttpServletRequest request) {
System.out.println("login()");
String username = request.getParameter("username");
String password = request.getParameter("password");
System.out.println("username = " + username + ", password = " + password);
return "index";
}
* 读取请求参数值的第二种方式，使用@RequestParam注解。
* 要注意，java反射机制一般情况下是获取不到参数值的名称，eclipse特殊编译出来的却可以，所以最好加上@RequestParam
@RequestMapping("/login2.do")
public String login2(String username,@RequestParam("password") String p) {
System.out.println("username = " + username + ", password = " + p);
System.out.println("login2.do");
return "index";
}
* 读取请求的第三种方式，将请求参数封装成一个javabean。
* AdminParam要求属性名与请求参数名一致，并且提供相应的get/set方法。
@RequestMapping("/login3.do")
public String login3(AdminParam ap) {
System.out.println("login3()");
System.out.println("username = " + ap.getUsername() + ", password = " + ap.getPassword());
return "index";
}
}
向页面传值的四种方式
向页面传值
- 1.使用request
将数据绑定到request，然后转发到某个jsp。
注：springmvc默认使用转发。
- 2.使用ModelAndView
将数据先封装到ModelAndView对象里面，然后将该对象作为
方法的返回值。
- 3.使用ModelMap
将该对象作为方法的参数，然后将数据绑定到该对象。
- 4.使用session
* 向页面传值的第一种方式，使用request
@RequestMapping("/login4.do")
public String login4(AdminParam ap, HttpServletRequest request) {
System.out.println("login4()");
String username = ap.getUsername();
System.out.println("username = " + username);
* 将数据绑定到request
request.setAttribute("username", username);
* springmvc默认使用转发
return "index";
}
* 向页面传值的第二种方式
* 使用ModelAndView
@RequestMapping("/login5.do")
public ModelAndView login5(AdminParam ap) {
System.out.println("login5()");
String username = ap.getUsername();
System.out.println("username = " + username);
* 构造ModelAndView对象
Map<String,Object> map = new HashMap<String,Object>();
* 相当于request.setAttribute("username",username);
map.put("username", username);
ModelAndView mav = new ModelAndView("index", map);
return mav;
}
* 向页面传值的第三种方式，使用ModelMap
@RequestMapping("/login6.do")
public String login6(AdminParam ap, ModelMap mm){
System.out.println("login6()");
String username = ap.getUsername();
System.out.println("username = " + username);
* 相当于request.setAttribute("username",username)
mm.addAttribute("username", username);
return "index";
}
* 向页面传值的第四种方式，使用session
@RequestMapping("login7.do")
public String login7(AdminParam ap, HttpSession session) {
System.out.println("login7()");
String username = ap.getUsername();
System.out.println("username = " + username);
session.setAttribute("username", username);
return "index";
}
jsp中的代码如下
login.jsp
<form action="login7.do" method="post">
<p>账号：<input type="text" name="username"/></p>
<p>密码：<input type="password" name="password"/></p>
<p><input type="submit" value="提交"/></p>
</form>
index.jsp
<h2>登陆成功</h2>
<h3>${username }</h3>
返回重定向
如果方法的返回值是String，在重定向地址前添加“redirect：”。
@RequestMapping("login8.do")
public String login8(AdminParam ap) {
return "redirect:toindex.do"; --- 得有一个toindex.do的跳转地址
}
如果方法的返回值是ModelAndView
@RequestMapping("/login9.do")
public ModelAndView login9(HttpServletRequest request) {
RedirectView rv = new RedirectView("toindex.do");
return new ModelAndView(rv);
}
网友评论