1) Spring是一个IOC(DI)和AOP容器框架。
1) Spring的优良特性
依赖注入：DI——Dependency Injection，反转控制(IOC)最经典的实现。
面向切面编程：Aspect Oriented Programming——AOP
一站式：在IOC和AOP的基础上可以整合各种企业应用的开源框架和优秀的第三方 类库（实际上Spring 自身也提供了表述层的SpringMVC和持久层的Spring JDBC）。
IOC(Inversion of Control)：反转控制
应用程序中的组件需要获取资源时，传统的方式是组件主动的从容器中获取所需要的资源；
反转控制的思想完全颠覆了应用程序组件获取资源的传统方式：反转了资源的获取方向——改由容器主动的将资源推送给需要的组件，开发人员不需要知道容器是如何创建资源对象的，只需要提供接收资源的方式即可
DI(Dependency Injection)：依赖注入
IOC的另一种表述方式：即组件以一些预先定义好的方式(例如：setter 方法)接受来自于容器的资源注入。相对于IOC而言，这种表述更直接。
IOC 描述的是一种思想，而DI 是对IOC思想的具体实现.
Bean配置解释
<bean>: 让IOC容器管理一个具体的对象.
id: 唯一标识
class: 类的全类名. 通过反射的方式创建对象.
Class cls = Class.forName("com.atguigu.spring.helloWorld.Person");
Object obj = cls.newInstance(); 无参数构造器
<property>: 给对象的属性赋值.
name: 指定属性名 ，要去对应类中的set方法.
value:指定属性值
获取Bean的方式
1) 从IOC容器中获取bean时，除了通过id值获取，还可以通过bean的类型获取。但如果同一个类型的bean在XML文件中配置了多个，则获取时会抛出异常，所以同一个类型的bean在容器中必须是唯一的。
//1.创建IOC容器 ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml"); //2.获取HelloWorld对象；唯一标示的id为“Hi” HelloWorld bean = (HelloWorld) ioc.getBean("Hi"); 或者这种方式来获取Bean： HelloWorld helloWorld = ioc.getBean(HelloWorld. class); 或者可以使用另外一个重载的方法，同时指定bean的id值和类型 HelloWorld helloWorld = cxt.getBean(“helloWorld”,HelloWorld. class); //3.调用HelloWorld中的方法 bean.sayHello();
给bean的属性赋值（普通类型的值、引用类型的值）
<!-- 给bean的属性赋值,（普通类型的值、引用类型的值）
1.通过vlaue属性或vlaue子标签（了解） 2.通过ref属性或ref子标签（了解）
-->
<bean id="employee" class="com.atguigu.spring.entities.Employee">
<property name="id" value="1"></property>
<property name="lastName">
<value>kk</value> 可使用<value>子标签来赋值；
</property>
<property name="email" value="kk@qq.com"> </property>
<property name="salary" value="10000"> </property>
<!-- <property name="deptId" value="2"> </property> -->
<property name="dept" ref="department"></property> 有引用数据类型的值
</bean>
配置Department，再将配置好的Department注入到Employee中（使用ref）
<bean id="department" class="com.atguigu.spring.entities.Department">
<property name="id" value="2"></property>
<property name="name" value="设计"></property>
</bean>
引用外部属性文件
<!-- 方式一:直接配置数据源 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="username" value="root"></property>
<property name="password" value="123456"></property>
<property name="url" value="jdbc:mysql://localhost:3306/test"></property>
<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
</bean>
<!-- 方式二: 引入外部属性文件以properties的格式 -->
<context:property-placeholder location="classpath:druid.properties"/>
<!-- 通过引入外部配置文件引入数据源 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="username" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
<property name="url" value="${jdbc.url}"></property>
<property name="driverClassName" value="${jdbc.driverClassName}"></property>
<property name="initialSize" value="${jdbc.initialSize}"></property>
<property name="minIdle" value="${jdbc.minIdle}"></property>
<property name="maxActive" value="${jdbc.maxActive}"></property>
<property name="maxWait" value="${jdbc.maxWait}"></property>
</bean>
创建properties属性文件（位于src/main/resources）；
在xml中引入context名称空间；
指定properties属性文件的位置；从properties属性文件中引入属性值
<!-- 指定properties属性文件的位置 --> <!-- classpath:xxx 表示属性文件位于类路径下 --> <context:property-placeholder location="classpath:jdbc.properties"/>
基于注解配置Bean
1) 手动装配：以value或ref的方式明确指定属性值都是手动装配。
2) 自动装配：根据指定的装配规则，不需要明确指定，Spring自动将匹配的属性值注入bean中。
相对于XML方式而言，通过注解的方式配置bean更加简洁和优雅，而且和MVC组件化开发的理念十分契合，是开发中常用的使用方式。
1) 普通组件：@Component
标识一个受Spring IOC容器管理的组件
2) 持久化层组件：@Repository
标识一个受Spring IOC容器管理的持久化层组件
3) 业务逻辑层组件：@Service
标识一个受Spring IOC容器管理的业务逻辑层组件
4) 表述层控制器组件：@Controller
标识一个受Spring IOC容器管理的表述层控制器组件
5) 组件命名规则
①默认情况：使用组件的简单类名首字母小写后得到的字符串作为bean的id
②使用组件注解的value属性指定bean的id
注意：事实上Spring并没有能力识别一个组件到底是不是它所标记的类型，即使将@Respository注解用在一个表述层控制器组件上面也不会产生任何错误，所以 @Respository、@Service、@Controller这几个注解仅仅是为了让开发人员自己明确当前的组件扮演的角色。
Spring Web MVC (SpringMVC)
Spring MVC 通过一套 MVC 注解，让 POJO 成为处理请求的控制器，而无须实现任何接口
C（controler ，处理用户请求的，与servlet功能是一样的，请求先到达C层；）
M（model模型控制器（业务模型和数据模型））
V（View视图，视图解析器来渲染视图）
请求到达C之后要去拿Model，它再返回给C数据，C再找View（数据以什么方式进行呈现给用户），V处理完之后把页面给C，最后它给用户。
表现层（出来用户请求的）、业务逻辑层（出来业务逻辑的）、持久化层（DAO连接数据库）。
SpringMVC在这个基础上又加了一个前端控制器（配置在web.xml中）；它负责分配，让哪个C去处理请求；
请求先到前端控制器它先拦截，由它来分配。
) 在web.xml中配置DispatcherServlet（前端控制器）
<?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"
id="WebApp_ID" version="2.5">
<!-- 配置前端控制器|核心控制器 DispatcherServlet -->
<servlet>
<servlet-name>springDispatcherServlet</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> 文件位置，服务器解析xml时来造这个对象，
</init-param>
<load-on-startup>1</load-on-startup> 服务器一启动就把对象造好了，不用发请求
</servlet>
<!-- Map all requests to the DispatcherServlet for handling -->
<servlet-mapping>
<servlet-name>springDispatcherServlet</servlet-name>
<url-pattern>/</url-pattern> /是为了覆盖tomcat服务器中的xml，为了替代default它拦截的请求（/它是除了jsp不拦截其他都拦截后交给它处理）；
</servlet-mapping> //替换它，替换它拦截的请求交给我处理； jsp有专门的jsp处理
<!-- 通过过滤方式配置中文,后端显示中文不会乱码 -->
<filter>
<filter-name>CharacterEncodingFilter</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>
<init-param>
<param-name>forceEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>CharacterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>
<?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/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd"> <!-- 设置自动扫描的包 --> <context:component-scan base-package="com.atguigu.springmvc"></context:component-scan> <!-- 配置视图解析器来渲染视图 --> <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver"> <!-- 配置前缀 --> <property name="prefix" value="/WEB-INF/views/"></property> <!-- 配置后缀 --> <property name="suffix" value=".jsp"></property> </bean> <!-- 处理静态资源,如加载juqery等 --> <mvc:default-servlet-handler/> <!-- 配置了处理静态资源之后，Handler中的@RequestMapping注解就失效了，此时必须配置以下标签 --> <mvc:annotation-driven></mvc:annotation-driven> </beans>
前缀 + 返回值 + 后缀，拼接起来 /WEB-INF/views/success.jsp
创建处理器（让当前类成为处理器，加@Controller注解）
index.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
<script type="text/javascript" src="${pageContext.request.contextPath}/script/jquery-1.7.2.js"></script>
<script type="text/javascript">
/* alert($); */
</script>
</head>
<body>
<a href="${pageContext.request.contextPath }/hello">Hello SpringMVC</a>
<br>
<a href="${pageContext.request.contextPath }/testValue">testValue</a>
<br>
<a href="${pageContext.request.contextPath }/testMethod">testMethod</a>
<form action="${pageContext.request.contextPath}/testMethod" method="post">
<input type="submit" value="提交">
</form>
<a href="${pageContext.request.contextPath}/testRequestParam?username=admin">test RequestParam</a>
<h2>测试入参POJO</h2>
<form action="${pageContext.request.contextPath }/testPOJO">
员工编号:<input type="text" name="id"><br>
员工姓名:<input type="text" name="lastName"><br>
员工邮箱:<input type="text" name="email"><br>
员工薪水:<input type="text" name="salary"><br>
部门编号:<input type="text" name="dept.id"><br>
部门名字:<input type="text" name="dept.name"><br>
<input type="submit" value="TestPOJO提交">
</form>
<h3>测试入参为原生SevletAPI</h3>
<form action="${pageContext.request.contextPath}/testServletAPI" method="post">
员工姓名:<input type="text" name="username">
<input type="submit" value="TesetServletAPI">
</form>
<!-- 转发 -->
<a href="${pageContext.request.contextPath }/testModelAndView">ModelView</a><br>
<a href="${pageContext.request.contextPath }/testMap">Map</a><br>
<!-- 重定向 -->
<a href="${pageContext.request.contextPath }/testRedirect">Redirect</a>
</body>
</html>
@Controller
public class SpringMVCHandler {
public static final String SUCCESS = "success";
/* @RequestMapping处理请求映射;注解中的属性
* 1.value -用来设置要映射的请求地址
-该属性的类型是一个String类型的数组，如果映射的请求地址（必须携带请求参数params）只有一个那么大括号可以省略， 而且value属性名也可以省略不写
2.method
-用来设置要映射的请求方式 -如果没有指定改属性如post，那么只看处理的请求地址，不管请求方式,不是默认出来get请求*/
//测试value
@RequestMapping(value={"/testValue", "testValue2"})
public String testValue() {
System.out.println("测试value");
return SUCCESS;
}
//测试method
@RequestMapping(value="/testMethod" ) 可加请求参数params={"username=admin", "age=18"}
public String testMethod() {
System.out.println("测试method");
return SUCCESS;
/*点击超链接是get请求*/
}
//测试post请求
@RequestMapping(value= "/testMethod", method=RequestMethod.POST)
public String testPost() {
System.out.println("测试post");
return SUCCESS;
}
/* @RequestParam注解 -用来映射请求参数，如果Handler方法的入参的参数名和请求参数的参数名一致，那么该注解可以不写（不建议这样）
value属性： -用来设置请求参数的参数名 required属性： -用来设置该请求参数是否是必须的，默认是true，是必须的
defaultValue属性： -用来设置一个默认值，如果没有携带该请求参数那么将使用此默认值*/
@RequestMapping("/testRequestParam")
public String testRequestParam(@RequestParam("username") String username,
@RequestParam(value="age", required=false, defaultValue="0") int age) { //或者Integer
System.out.println("用户名是:" + username);
System.out.println("年龄是:" + age);
return SUCCESS;
}
//Spring MVC 会按请求参数名和 POJO 属性名进行自动匹配， 自动为该对象填充属性值，支持级联属性
@RequestMapping("/testPOJO")
public String testPOJO(Employee employee) {
System.out.println("员工信息为:" + employee);
return SUCCESS;
}
/*SpringMVC 的 Handler 方法可以接受以下ServletAPI 类型的参数 1) ★HttpServletRequest 2)* ★HttpServletResponse
3) ★HttpSession */
@RequestMapping("/testServletAPI")
public String testSevletAPI(HttpServletRequest request, HttpServletResponse response) {
String username = request.getParameter("username");
System.out.println("用户名是:" + username);
return SUCCESS;
}
//处理响应数据方法一:将Handler的方法的返回值设置为ModelAndView
@RequestMapping("/testModelAndView")
public ModelAndView testModelAndView() {
//①创建对象
ModelAndView mv = new ModelAndView();
Employee employee = new Employee(2, "嘿嘿", "hei@qq.com", 20000.3, null);
//②添加数据模型
mv.addObject("emp", employee);
//③设置视图名
mv.setViewName("success");
return mv;
}
//处理响应数据二:
/*方法的返回值还是String类型，在Handler的方法入参中传入Map、Model或ModelMap
不管在Handler的方法中传入Map、Model还是ModelMap，SpringMVC都会转换为一个ModelAndView对象*/
@RequestMapping("/testMap")
public String testMap(Map<String, Object> map) {
Employee employee = new Employee(1, "smile", "sl@126.com", 20000.01, null);
map.put("emp", employee); //将模型数据放到map中，最终会放到request域中
return SUCCESS;
}
//重定向
@RequestMapping("/testRedirect")
public String testRedict() {
System.out.println("开始重定向");
return "redirect:/redirect.jsp";
}
}
Spring与SpringMVC需不需要整合？ * 不整合 * 1.将所有的配置都配置到SpringMVC的配置文件中 * 2.将Spring的配置文件通过import标签引入到SpringMVC的配置文件中 * ★整合 * Spring的配置文件中管理Service、Dao、数据源、事务以及与其他框架的整合 * SpringMVC的配置文件管理Handler、视图解析器、处理静态资源等 * 问题一： * IOC容器如何初始化？ * Java工程：new ClassPathXmlApplicationContext("beans.xml"); * Web工程：在web.xml文件中配置ContextLoaderListener这个监听器 * 问题二： * Handler和Service被创建了两次？ * 让Spring不扫描Handler * 让SpringMVC只扫描Handler
springmvc.xml
<!-- 组件扫描 -->
<!-- 子标签context:include-filter：用来设置只扫描那个包下的类
-要让此标签生效，必须将父标签的use-default-filters的属性值改为false -->
<context:component-scan base-package="com.atguigu.ss" use-default-filters="false">
<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
<!-- 视图解析器 -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/views/"></property>
<property name="suffix" value=".jsp"></property>
</bean>
beans.xml
<!-- 设置自动扫描的包 -->
<context:component-scan base-package="com.atguigu.ss">
<!-- 子标签context:exclude-filter：用来设置不扫描那个包下的类
如果type的值是annotation，那么expression的值是注解的全类名
如果type的值是assignable，那么expression的值是接口或实现类的全类名 -->
<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan >
web.xml
<!-- 前端控制器 -->
<servlet>
<servlet-name>springDispatcherServlet</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>
<!-- Map all requests to the DispatcherServlet for handling -->
<servlet-mapping>
<servlet-name>springDispatcherServlet</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
<!-- 配置ContextLoaderListener监听器; Web工程-->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:beans.xml</param-value>
</context-param>
<!-- Bootstraps the root web application context before servlet initialization -->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>