SPRING

1：spring框架的功能：

Spring框架比较繁杂，功能较多的框架，主要创建、销毁、管理对象，项目bean对象管理粘合剂，相当与项目管家。主要通过IOC与AOP两大技术实现。

2：spring框架优点：

1）方便解耦，简化开发 Spring 就是一个大工厂，可以将所有对象的创建和依赖关系的维护交给 Spring 管理。 2）方便集成各种优秀框架 Spring 不排斥其他各种优秀的开源框架，其内部提供了对各种优秀框架（如 Struts2、Hibernate、MyBatis等）的支持。 3）降低 Java EE API 的使用难度 Spring 对 Java EE 开发中非常难用的一些 API都提供了封装，使这些API 应用的难度大大降低。 4）AOP 编程的支持 Spring 提供面向切面编程，可以方便地实现对程序进行权限拦截和运行监控等功能。 5）声明式事务的支持只需要通过配置就可以完成对事务的管理，而无须手动编程。

6）面向接口编程

3：IOC：控制反转：

原来项目代码中对象都是由我们自己new创建(我们负责对象的创建，项目不管)，现在引入spring框架，由spring框架创建对象(对象不由我们创建，由spring框架创建) 所有bean(对象)交给spring容器管理，由spring创建、销毁对象，统一管理(不使用new创建)。默认所有对象单例模式。原来所有的对象都是通过代码开发者自己new，控制权在开发者自己手上，现在交给spring管理，对象的控制权交给代码自己，称之为控制反转。

a：IOC容器创建对象

1):方式1：构造器实例化

默认调用无参构造器

1：新建maven项目,在pom.xml文件定义：
    <dependencies>
        <!--代码测试包-->
        <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>4.11</version>
          <scope>test</scope>
        </dependency>
        <!--spring核心工具包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.2.12.RELEASE</version>
        </dependency>
        <!--IOC工具包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.2.12.RELEASE</version>
        </dependency>
        <!--依赖注入包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.12.RELEASE</version>
        </dependency>
        <!--spring表达式包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>5.2.12.RELEASE</version>
        </dependency>
    </dependencies>

2：自定义类：
	package com.woniu.service;
    public class StuServiceImp implements StuService {
        public StuService(){
            System.out.println("StuService构造器......");
        }
        public void addStu(){
            System.out.println("addStu方法.......");
        }
    }

3：在src/main/resources包根目录创建spring核心配置文件：springConfig.xml,复制基本结构
	<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"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
		
        <!--该bean交给spring管理：创建、销毁、管理对象，创建出来对象的名字叫做stuService-->
    	<bean id="stuService" class="com.woniu.service.StuService"></bean>
	</beans>
	注意：所有在该xml文件中定义的bean对象，都交给spring管理(创建、销毁等等.....)


4：创建ioc容器对象，并获得对象
    public class Test {
        public static void main(String[] args) {
            //创建一个IOC容器对象(读取springConfig.xml文件，创建所有bean对象。)
            ApplicationContext context = 
                                new ClassPathXmlApplicationContext("/springConfig.xml");
            //根据id获得对象
            StuService stuService1 = (StuService)context.getBean("stuService");
            //根据类名获得对象
            StuService stuService2 = context.getBean(StuService.class);
            System.out.println(stuService1);
            System.out.println(stuService2);
            stuService1.addStu();
        }
    }

2):方式2：静态工厂模式

1：自定义类：
    package com.woniu.service;
    public class StuService {
        public StuService(){
            System.out.println("StuService构造器......");
        }
        public void addStu(){
            System.out.println("addStu方法.......");
        }
    }
2：创建静态工厂类：
    package com.woniu.factory;
    public class StaticFactory {
        public static StuService createStuService(){	//必须是静态方法
            return new StuService();
        }
    }
3：springConfig.xml管理该工厂bean
    <bean id="staticFactory" class="com.woniu.factory.StaticFactory" 
        									factory-method="createStuService"></bean>
4：获得bean对象：
	ApplicationContext context = new ClassPathXmlApplicationContext("/springConfig.xml");
    StuService stuService = (StuService)context.getBean("staticFactory");
    stuService.addStu();

定义静态工厂的好处：一个工厂可以生产多个同类型的产品(简单工厂模式)：例如不同的方法创建不同的产品。
    <bean id="staticFactory2" class="com.woniu.factory.StaticFactory" 
        									factory-method="createStuServic"></bean>
    <bean id="staticFactory3" class="com.woniu.factory.StaticFactory" 
        									factory-method="createStuService2"></bean>

3):方式3：实例工厂模式

1：自定义类：
    package com.woniu.service;
    public class StuService {
        public StuService(){
            System.out.println("StuService构造器......");
        }
        public void addStu(){
            System.out.println("addStu方法.......");
        }
    }
2：创建实例工厂类：
	public class InstanceFactory {
        public StuService createStuService(){	//区别就是非静态方法
            return new StuService();
        }
    }
3：springConfig.xml管理该工厂bean
    <!--通过无参构造器创建工厂对象-->
    <bean id="instanceFactory" class="com.woniu.factory.InstanceFactory"></bean>
    <!--调用哪个工厂对象(factory-bean)的哪个方法(createStuService)创建对象,对象的id：-->    
    <bean id="stuService" factory-bean="instanceFactory" 
        										factory-method="createStuService"></bean>
3：获得bean对象：
	ApplicationContext context = new ClassPathXmlApplicationContext("/springConfig.xml");
    StuService stuService = (StuService)context.getBean("stuService");
    stuService2.addStu();

4):方式4：注解方式

在类头上添加@Component:创建对象的注解，相当于定义<bean id="" class=""></bean>
	@Component
	public class StuService {}
	@Component
	public class StuDao {}

	注意：
		如果使用注解方式，则springConfig.xml文件中需要启用注解开发和扫描注解类路径。
		<!-- 启用注解开发 -->
		<context:annotation-config></context:annotation-config>
		<!-- 配置自动扫描注解路径，哪些路径使用了注解 -->
		<context:component-scan base-package="com.aaa.dao,com.aaa.service">
		</context:component-scan>
        注意添加context命名空间与语法规范
     	1：复制xmlns:p="http://www.springframework.org/schema/p"粘贴到下面一行，注意属性空格隔
     	开，把p改成context
        2：复制xsi:schemaLocation的属性值，粘贴到双引号里面最后，有空格隔开，把3个beans修改成
        		context
        <beans 
			default-autowire="byName"
			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-3.0.xsd 
				http://www.springframework.org/schema/context 	
				http://www.springframework.org/schema/context/spring-context-3.0.xsd">
		</beans>

b：bean的作用域：

singleton （单例模式）：spring容器中仅有一份对象，默认
		<bean id="stuService" class="xa.woniu.service.StuService" scope="singleton">	
		</bean>  

prototype：（原型模式）每次通过容器获得该对象时创建新对象
		<bean id="stuService" class="xa.woniu.service.StuService" scope="prototype">
		</bean>

request：每次请求创建一份新对象
		<bean id="stuService" class="xa.woniu.service.StuService" scope="request"></bean>
		
session：每次会话创建新对象，
		<bean id="stuService" class="xa.woniu.service.StuService" scope="session"></bean>
		
globalsession：web环境下与session相同的，参与小程序开发才有区别。
		<bean id="stuService" class="xa.woniu.service.StuService" scope="globalsession">		</bean>


@Scope("singleton")
@Component()

c：IOC的父接口：

BeanFactory：ApplicationContext的父接口，Bean工厂，负责在容器中获得bean对象。
    
		//获得工厂时，不会创建bean对象，
		BeanFactory beanFactory = 
						new XmlBeanFactory(new ClassPathResource("springConfig.xml"));
		//创建bean对象
        StuService stuService = (StuService)beanFactory.getBean("stuService");
        stuService.addStu();

		
		//获得容器对象会创建bean对象
		 ApplicationContext context = 
                                new ClassPathXmlApplicationContext("/springConfig.xml");


BeanFactory：springIOC中最大的父接口，下面有不同的子接口，不同的子接口决定了什么时候创建bean对象

d：DI：依赖注入：

spring执行IOC的时候，每一个类当中通常会有类属性：spring不建议new对象，通过工厂模式把容器创建的对象赋值给类属性，简单理解：IOC容器在创建对象A时，需要给该对象A的类属性赋值的过程：称之为依赖注入

方式1：set注入：
    1：给类属性添加set方法
    		public class StuService2 {
                private StuMapper sm1;
                private String xxx;
                public void setSm1(StuMapper sm1) {
                    this.sm1 = sm1;
                }
                public void setXxx(String xxx){
                    this.xxx = xxx;
                }
            }
	2：spring.xml给该StuService2执行依赖注入：
        <bean id="stuService2" class="xa.woniu.mapper.StuService2">
            	把stuMapper2对象赋值给当前对象的sm1属性
			<property name="sm1" ref="stuMapper2"></property>
            	把字符串常量abc赋值给xxx属性
            <property name="xxx" value="abc"></property>
		</bean>
        <bean id="stuMapper2" class="xa.woniu.service.StuMapper2"></bean>
方式2：构造器注入：
    1：给类添加有参构造器：
        public class StuService2 {
			String a;
			StuMapper2 sm1;
            public StuService2(StuMapper2 sm1,String a) {
                this.sm1 = sm1;
                this.a = a;
                System.out.println("stuService2构造器3。。。。。。");
        	}
     2：spring.xml给stuService2对象执行依赖注入：
         <bean id="stuService2" class="xa.woniu.service.StuService2">
            <constructor-arg index="0" ref="stuMapper2"></constructor-arg>
             	通过构造器注入：构造器中参数下标为0的对象注入stuMapper2
            <constructor-arg index="1" value="abc"></constructor-arg>
              	通过构造器注入：构造器中参数下标为1的对象注入abc字符串常量
        </bean>
方式3：自动注入(自动装配)：类中的属性依然需要set方法或者构造器
        <bean id="stuService2" class="xa.woniu.service.StuService2" autowire=""></bean>
        autowire：自动注入
            byName:stuService2当中的类属性名与当前xml文件中对象名相同时，必须有set方法，自动注入
            byType:stuService2当中的类属性的数据类型与当前xml文件中对象数据类型相同时，必须有set方
                	法，自动注入
            constructor：调用有参构造器。先根据构造器中名字相同注入，如果参数名字与容器中对象名不匹配，则根据类型注入。
                
            default:根据全局注入方式来实现自动注入：
                	全局注入方式：如果全局注入方式为根据名称，那么所有的bean标签中autowire="default"也是根据名称自动注入
                			<beans default-autowire="byName">	
                			</beans>

 方式4：注解方式注入： 
		 @Value("yyy")：java定义的注解，给简单类型直接赋值(8中基本类型的包装类及字符串)
         @Resource:自动注入注解，默认按照名称方式进行bean匹配(autowire=”byName”),如果没有匹配名				字，则按照类型进行匹配，如果匹配失败抛出异常。 是Java定义的注解。
		 @Autowired:自动注入注解，默认先按byType进行匹配(autowire=”byType”)，如果发现找到多个
             bean，则再按照byName方式进行匹配，如果还有多个，则报出异常。Spring框架自己的注解。
         不需要set方法与构造器    
             
             
         @Autowired(required=false)，required=false：可以不注入或者注入的对象允许使用null值，
         @Autowired()可以与@Qualifier("testDao")配合使用,使用名称自动注入
         相当于：<bean id="" class="" autowire="byName/byType"></bean>
         注意：
		如果使用注解方式，则spring.xml文件中需要启用注解开发和扫描注解类路径。
		<!-- 启用注解开发 -->
		<context:annotation-config></context:annotation-config>
		<!-- 配置自动扫描注解路径，哪些路径使用了注解 -->
		<context:component-scan base-package="com.aaa.dao,com.aaa.service">
		</context:component-scan>
        注意添加context命名空间与语法规范
     	1：复制xmlns:p="http://www.springframework.org/schema/p"粘贴到下面一行，注意属性空格隔
     	开，把p改成context
        2：赋值xsi:schemaLocation的属性值，粘贴到双引号里面最后，有空格隔开，把3个beans修改成
        		context
        <beans 
			default-autowire="byName"
			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-3.0.xsd 
				http://www.springframework.org/schema/context 	
				http://www.springframework.org/schema/context/spring-context-3.0.xsd">
		</beans>

e：FactoryBean与BeanFactory：

1)：FactoryBean：

可以自己实现该接口实现自己需求的注入功能。

public class StuDao {
    public void addStu(){
        System.out.println("addStu.........");
    }
}
public class StuService {
    private StuDao stuDao;
    public void setStuDao(StuDao stuDao) {  //需要自己自己实现注入StuDao对象
        this.stuDao = stuDao;
    }

    public void addStu(){
        stuDao.addStu();
    }
}

//该工厂负责创建StuService对象，并注入StuDao
public class MyFactoryBean implements FactoryBean<StuService> {
    //通过配置文件注入，准备给getObject方法创建的对象实现DI
    private StuDao stuDao;
    public void setStuDao(StuDao stuDao) {
        this.stuDao = stuDao;
    }
    //通过IOC容器获得当前工厂对象时，自动调用当前方法返回对象
    public StuService getObject() throws Exception {	
        StuService stuService = new StuService();
        stuService.setStuDao(stuDao);
        return stuService;
    }
    public Class<?> getObjectType() {
        return StuService.class;
    }
	//定义通过getObject方法创建的对象是否是单例
    public boolean isSingleton() {
        return true;
    }
}
//在springConfig.xml管理该bean
    <bean id="stuDao" class="com.woniu.dao.StuDao"></bean>
    <bean id="myFactory" class="com.woniu.util.MyFactoryBean">
		<property name="stuDao" ref="stuDao"></property>
    </bean>
//main函数测试：
	ApplicationContext context = new ClassPathXmlApplicationContext("/springConfig.xml");
	StuService stuService1 = (StuService)context.getBean("myFactory");
	StuService stuService2 = (StuService)context.getBean("myFactory");
	System.out.println(stuService1);
	System.out.println(stuService2);

2)：BeanFactory

BeanFactory：
	1:Spring容器根接口，工厂模式，给Spring的容器定义一套规范，给IOC容器提供了一套完整的规范，负责创建获取对象，比如我们常用到的getBean方法。
		常用定义方法：
            getBean(String name): Spring容器中获取对应Bean对象的方法，如存在，则返回该对象
            containsBean(String name)：Spring容器中是否存在该对象
            isSingleton(String name)：：判断bean对象是否为单例对象
            isPrototype(String name)：判断bean对象是否为多例对象
            getType(String name)：获取Bean的Class类型
	2：主要的实现类、抽象子类：
            AbstractBeanFactory：抽象Bean工厂，绝大部分的实现类，都是继承于他
            DefaultListableBeanFactory:Spring默认的工厂类
            XmlBeanFactory：前期使用XML配置用的比较多的时候用到的Bean工厂
            AbstractXmlApplicationContext:抽象应用容器上下文对象
            ClassPathXmlApplicationContext:Spring上下文对象，用户创建Bean对象我们早期写Spring的时候用的就是他
	3：
		//获得工厂时，不会创建bean对象，
		BeanFactory beanFactory = 
						new XmlBeanFactory(new ClassPathResource("springConfig.xml"));
		//获得工厂时，会创建bean对象，
		BeanFactory beanFactory =  	
            			new ClassPathXmlApplicationContext("springConfig.xml");
		//创建bean对象
        StuService stuService = (StuService)beanFactory.getBean("stuService");
        stuService.addStu();

3)：区别：

BeanFactory是个factory(工厂)，是springIOC中顶级接口，负责创建对象，创建对象时严格按照spring创建对象的复杂流程之后，默认创建出来单例模式对象,常用功能：
	从Ioc容器中获取Bean对象：beanFactory.getBean(String name)
	检索Ioc容器中是否包含指定的Bean:beanFactory.containsBean(String name)
	判断Bean是否为单例:beanFactory.isSingleton(String name)
	
FactoryBean是个bean(对象)，是负责创建对象并实现注入功能。FactoryBean为我们实例化Bean提供了一个更为灵活的方式，我们可以通过FactoryBean创建出一个按照自己需求注入的实例。常用功能：
	创建对象：getObject()
	返回类型：getObjectType()
	定义创建的对象是否是单例：isSingleton()

总结：

1：什么是IOC
2：有几种方式？
3：什么是DI
4：有几种方式？
5：两个接口的区别

作业1：spring核心配置文件种定义bean并实现注入（EmpService,EmpDao）
作业2：注解方式实现如上任务。

4：复习代理的作用

Aop的实现原理是通过代理模式实现，aop使用了jdk动态代理和cglib动态代理，根据目标对象有没有实现接口，如果有实现接口，则生成jdk动态代理，如果目标对象没有实现接口，则使用cglib动态代理对象

5：AOP:面向切面编程：

OOP：面向对象编程：纵向编程。

servlet

↓

service

↓

mapper

AOP：横向编程，不是用来替代OOP，而是对OOP的补充。

servlet

↓

service

↓

→aop代码

mapper

→aop代码

基本概念：
		aop：横向编程,在指定位置(类、方法)之前或者之后添加任意代码(什么位置？什么代码？之前还是之后？或者之前和之后？)
		应用场景：日志，事务，权限，检测。。。。。
		
		
		需要引入的依赖：
			<!--aop核心包-->
            <dependency>
              <groupId>org.springframework</groupId>
              <artifactId>spring-aop</artifactId>
              <version>${spring.version}</version>
            </dependency>
            <!--aspectj切面包-->
            <dependency>
              <groupId>org.aspectj</groupId>
              <artifactId>aspectjrt</artifactId>
              <version>1.9.7</version>
            </dependency>
            <dependency>
              <groupId>org.aspectj</groupId>
              <artifactId>aspectjweaver</artifactId>
              <version>1.9.19</version>
            </dependency>

		基本概念：
			Joinpoint：连接点：切面中需要加入公共程序的地方！(一个具体位置)
			pointcut：切入点：符合某种规则的连接点，好多个连接点用对象化表示出来！(多个连接点用表达式来表示，好多个位置)
			Advice：通知：需要加入的公共程序！(要添加的代码)
			Aspect：切面，在连接点上做的一系列行为,把通知和切入点整合(aop整体)

			通知类型：重点是方法中的参数，自己找源代码
			环绕通知，org.aopalliance.intercepter.MethodInterceptor:目标方法前和后调用，阻止方法调用！
			前置通知，org.springframework.aop.MethodBeforeAdvice:在目标方法前调用
			后置返回通知(最终通知)，org.springframework.aop.AfterReturningAdvice:在目标方法后调用
			异常通知，org.springframework.aop.ThrowsAdvice：当目标方法抛出异常时调用，该接口为标识接口，需要按如下规则定义方法：空接口：在注解当中使用
			后置通知  spring3.0已经废弃该接口，但是注解中仍然有！

实现方式1：静态代理方式实现
<bean id="proxyA" class="org.springframework.aop.framework.ProxyFactoryBean">	ProxyFactoryBean：代理对象
		<property  name="target" ref="stuService"/>	target：需要注入被代理对象，ref：注入被代理的对象
		<property  name="interceptorNames">		interceptorNames：注入通知：after、before通知对象
			<list>
				<value>after</value>			//通知对象
				<value>before</value>
			</list>
		</property>
</bean>

<bean id="empMapper" class="com.woniu.mapper.EmpMapper"></bean>
<bean id="empService" class="com.woniu.service.EmpService">			被代理对象
	<property name="empMapper" ref="empMapper"></property>
</bean>
<bean id="after" class="com.woniu.advice.AfterAdvice"></bean>		通知类，注意实现接口
<bean id="before" class="com.woniu.advice.BeforeAdvice"></bean>
<bean id="around" class="com.woniu.advice.AroundAdvice"></bean>
<bean id="throw" class="com.woniu.advice.ThrowsAdvice"></bean>


public class AfterAdvice implements AfterReturningAdvice {
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("后置通知开始执行。。。。。。。。。。");
        System.out.println("被代理方法的返回值是："+returnValue);
        System.out.println("被代理对象的方法是："+method.getName());
        System.out.println("被代理对象的实参是："+ Arrays.toString(args));
        System.out.println("被代理的对象是："+target.getClass().getName());
        System.out.println("后置通知执行完毕。。。。。。。。。。");
        System.out.println();
    }
}    

public class BeforeAdvice implements MethodBeforeAdvice {
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println("前置通知开始执行..................");
        System.out.println("被代理的对象执行的方法："+method+","+method.getName());
        System.out.println("被代理的对象执行的方法的实参是："+ Arrays.toString(args));
        System.out.println("被代理的对象是："+target+","+target.getClass().getName());
        System.out.println("前置通知执行完毕..................");
        System.out.println();
    }
}

public class AroundAdvice implements MethodInterceptor {
    public Object invoke(MethodInvocation invocation) throws Throwable {
        System.out.println("环绕通知开始执行...............");
        Object returnValue = invocation.proceed();
        System.out.println("环绕通知执行完毕...............");
        System.out.println();
        return returnValue;
    }
}


public class ThrowsAdvice implements org.springframework.aop.ThrowsAdvice {
    public void afterThrowing(Method method,Object[] obj,Object target,Exception e) throws  Throwable{
        System.out.println("被代理对象执行方法发生异常了。。。。。。。");
        System.out.println("被代理对象执行的方法是"+method.getName());
        System.out.println("被代理对象执行的方法实参是"+ Arrays.toString(obj));
        System.out.println("被代理对象是"+target.getClass().getName());
        System.out.println("被代理对象执行方法发生的异常是："+e.getMessage());
    }
}

ApplicationContext ac = new ClassPathXmlApplicationContext("/applicationContext.xml");
StuService sm1  = (StuService)ac.getBean("proxyA");
sm1.add("aaa",10);
System.out.println("=============================");
sm1.update(10,"bbb");

实现方式2：使用<aop:pointcut>自定义切入点方式：注意自定义通知类的方法的参数是固定类型

	<bean id="empMapper" class="com.woniu.mapper.EmpMapper"></bean>
    <bean id="empService" class="com.woniu.service.EmpService">
		<property name="empMapper" ref="empMapper"></property>
    </bean>	
	<bean id="myadvice" class="com.woniu.advice.Myadvice"></bean>
    
    定义aop配置
	<aop:config>	
		定义切入点：id：myPointcut，expression：通过表达式将连接点定义为切入点
		<aop:pointcut expression="execution(* xa.woniu.mapper.*.*(..))" id="myPointcut"/> 
		定义切面，将通知myAdvice对象关联到该切面上
		<aop:aspect id="myAspect" ref="myadvice">	
			定义前置通知，注入到myPointcut切入点上
			<aop:before method="qianzhi" pointcut-ref="myPointcut" />
            定义后置返回通知，注入到myPointcut切入点上
            <aop:after-returning method="AfterReturning" pointcut-ref="myPointcut"  returning="obj" />
            <aop:after method="houzhi" pointcut-ref="myPointcut"></aop:after>
            <aop:around method="huanrao" pointcut-ref="myPointcut"></aop:around>
            <aop:after-throwing method="yichang" pointcut-ref="myPointcut"></aop:after-throwing>
		</aop:aspect>
	</aop:config>


自定义通知类，自定义方法。
import java.util.Arrays;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
public class Myadvice {
    public void qianzhi(JoinPoint jp){
        System.out.println("前置通知开始。。。。");
        System.out.println("被代理的对象是："+jp.getTarget().getClass().getName()+"   ");
        System.out.println("被代理的方法是："+jp.getSignature().getName()+"   ");
        System.out.println("被代理的方法实参是："+ Arrays.toString(jp.getArgs())+"   ");
        System.out.println("前置通知结束。。。。");
        System.out.println();
    }

    public void houzhi(JoinPoint jp){
        System.out.println("后置通知开始。。。。");
        System.out.print("后置通知：");
        System.out.print("被代理的对象是："+jp.getTarget().getClass().getName()+"   ");
        System.out.print("被代理的方法是："+jp.getSignature().getName()+"   ");
        System.out.print("被代理的方法实参是："+Arrays.toString(jp.getArgs())+"   ");
        System.out.println("后置通知结束。。。。");
        System.out.println();
    }
    public void houzhifanhui(JoinPoint jp, Object obj){
        System.out.println("后置返回通知开始。。。。");
        System.out.print("被代理的对象是："+jp.getTarget().getClass().getName()+"   ");
        System.out.print("被代理的方法是："+jp.getSignature().getName()+"   ");
        System.out.print("被代理的方法实参是："+Arrays.toString(jp.getArgs())+"   ");
        System.out.println("被代理的方法返回值是:"+obj);
        System.out.println("后置返回通知结束。。。。");
        System.out.println();
    }
    public void yichang(JoinPoint jp){
        System.out.println("异常通知。。。。");
    }
    public Object huanrao(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("环绕通知开始。。。。");
        Object obj = pjp.proceed();
        System.out.println("环绕通知结束。。。。");
        return obj;
    }
}





        
 实现方式3：注解方式：
        <aop:aspectj-autoproxy></aop:aspectj-autoproxy>		启用aop代理对象
        
        注意启用注解开发和扫描包路径的配置：
        <context:annotation-config></context:annotation-config>
        <context:component-scan base-package="com.woniu.mapper,com.woniu.service,com.woniu.advice"></context:component-scan>
        
        @Component  创建对象注解
        @Aspect		定义切面注解：定义在通知头上
		@Before("execution(* xa.woniu.mapper.*.*(..))")	通知方法注解
		@After("execution(* xa.woniu.mapper.*.*(..))")
		@Around("execution(* xa.woniu.mapper.*.*(..))")
        @AfterThrowing("execution(* xa.woniu.mapper.*.*(..))")
        @AfterReturning(pointcut="execution(* xa.woniu.mapper.*.*(..))",returning="obj")		//obj为返回值，必须与方法第二个参数名相同
        
注意：使用注解方式实现IOC，创建出来的对象名字是类名：首字母小写

6：整合mybatis

1：引入mybatis,mysql,pageHelper依赖：
	<!--mysql依赖-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>8.0.11</version>
    </dependency>
    <!--mybatis依赖-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.2</version>
    </dependency>
    <!--spring对mybatis管理集成-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>2.0.2</version>
    </dependency>
    <!--mybatis分页-->
    <dependency>
      <groupId>com.github.pagehelper</groupId>
      <artifactId>pagehelper</artifactId>
      <version>5.1.8</version>
    </dependency>
	<!--spring对jdbc封装的依赖-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.2.12.RELEASE</version>
    </dependency>
2：
<!-- 定义数据源对象-->
		<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
			<property name="driverClassName" value="com.mysql.cj.jdbc.Driver" />    
			<property name="url" value="jdbc:mysql://localhost:3306/test1?serverTimezone=GMT" />    
			<property name="username" value="root" />    
			<property name="password" value="eduask" />    
		</bean>
3：
		<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
                <!-- 注入数据源对象 -->
                <property name="dataSource" ref="dataSource" />
                <!-- 加载mybatis的全局配置文件 -->
                <property name="configLocation" value="classpath:myBatisConfig.xml" />
        </bean>

4：
		<!-- 该对象扫描com.woniu.mapper的mapper接口，反射创建实现类，@Repository实现-->
		<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
			<property name="basePackage" value="com.woniu.mapper"></property>
			<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
		</bean>


5：src/main/resources包根目录创建myBatisConfig.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>
			<plugins>
                <plugin interceptor="com.github.pagehelper.PageInterceptor" >
                    <property name="reasonable" value="true"/>
                </plugin>
            </plugins>
            <mappers>
                <mapper resource="com/woniu/dao/EmpMapper.xml"/>
            </mappers>
        </configuration>
        注意：将EmpMapper.xml放在resources/com/woniu/mapper/EmpMapper.xml

6：编写mapper接口与mapper.xml文件：
	mapper接口定义在com.woniu.mapper包
	mapper.xml文件定义在resources包中新建：com/woniu/mapper包：



7：main函数测试代码：
	ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("/springConfig.xml");
        EmpService empService = (EmpService)context.getBean(EmpService.class);
        Emp emp = new Emp();
        emp.setEname("ttt");
        System.out.println(empService.addEmp(emp));		
注意：采用mybatis默认事务：根据日志观察：
	每次使用mapper调用方法之前：Creating a new SqlSession，
	每次使用mapper调用方法之后：Closing non transactional SqlSession(关闭非事务性sql会话:没有事务处理)，所以在业务层中使用mapper调用两次方法，中间发生异常，则最终结果：第1个方法成功，第二个方法没有执行。
	
	spring整合mybatis链接数据库后，会使用Https的协议链接数据，如果没有定义，则报出SSL参数的警告，所以给jdbc的url参数添加一个参数：jdbc:mysql://localhost:3306/shop?serverTimezone=GMT&amp;useSSL=false

6：事务处理：

事务的特性：
	ACID，即原子性(atomicity)、一致性(consistency)、隔离性(isolation)和持久性(durability)。

事务隔离级：即项目放在网络服务器上，客户端访问服务器有可能产生并发问题：有两个客户端同时并发访问服务器同一张表数据，一个事务修改了一行数据，还未提交。另外一个事务查询全表数据，那么这个事务要不要或者能不能查询到未提交的数据呢？当存在多个事务并发的时候，会产生更新丢失、脏读、不可重复读、幻读等问题。这时就要看事务的隔离级别。


mysql隔离级别：
	read_uncommitted：事务可以读取到另一个事务未提交的事务记录
	read_committed：事务只能读取到已经提交的记录
	repeatable_read：一个事务在同一数据上进行多次查询时，但是其他事务添加、修改相同条件的数据时，当前事务不可见。这个隔离级别可以避免脏读的问题，但可能发生幻读的问题（mysql默认方式）
	serializable：最强的隔离级别。事务执行时，会在所有操作上加锁，比如read和write时都会加锁，仿佛事务是以线行的方式进行的，而不是一起发生的。这会防止脏读和幻读的出现，但是，会带来性能的下降。

	更改：打开mysql/data/mysql.ini文件，添加“transaction-isolation=事务级别”语句即可。

多事务并发时可能产生如下问题：

脏读
	脏读又称无效数据读出。一个事务读取另外一个事务还没有提交的数据。例如，事务T1修改了一行数据，但是还没有提交，这时候事务T2读取了被事务T1修改后的数据，之后事务T1因为某种原因Rollback了，那么事务T2读取的数据就是脏的。

不可重复读
	指在同一个事务内，对同一行数据的多次查询，返回了不同的结果。例如，事务T1第一次查询了某行数据，然后事务T2对这行数据的某个字段做了修改，并且提交了数据。事务T1第二次查询该行数据的时候，得到了事务T2修改过的结果。不可重复读和脏读的区别在于，脏读是读了未提交的数据，而不可重复读是读了提交了的数据。当然，不可重复读在某些情况下并不是问题，有时候我们就是要在同一事务下查询到数据的最新状态。

幻读
	幻读又称虚读。同一条SQL语句在同一个事务中的多次查询，得到的数据量（条数）不一样。例如，事务T1对一个表中所有的行的某个数据项做了从“1”修改为“2”的操作，这时事务T2又对这个表中插入了一行数据项，而这个数据项的数值还是为“1”并且提交给数据库。而操作事务T1的用户如果再查看刚刚修改的数据，会发现还有一行没有修改，其实这行是从事务T2中添加的，就好像产生幻觉一样，这就是发生了幻读。



事务功能是AOP的体现：
方式1：xml声明式事务
<bean id="transactionManager" <!--创建事务管理器对象-->
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource" />
</bean>
<!--给transactionManager对象定义事务通知-->
<tx:advice id="ttt" transaction-manager="transactionManager">
		<tx:attributes>
				<tx:method name="*" propagation="REQUIRED" />		事物传播行为:所有方法都添加事务
	            <tx:method name="sel*" propagation="NOT_SUPPORTED" />		sel开头的方法不添加事务
		</tx:attributes>
</tx:advice> 
<aop:config>	 <!-- 定义aop配置-->
			<!--定义切面-->
			<aop:pointcut id="aaa" expression="execution(* com.aaa.service.*.*(..))" />
			<!--切面与通知关联-->
			<aop:advisor pointcut-ref="aaa" advice-ref="ttt" />
</aop:config>
 


方式2：注解方式事务
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource" />
</bean>
<tx:annotation-driven transaction-manager="transactionManager"/>	启用事务注解
@Transactional
@Transactional(propagation=Propagation.NOT_SUPPORTED)
    
@Component
@Transactional
public class BookService {
	@Transactional(propagation=Propagation.NOT_SUPPORTED)   //没有事务
	public int selAll(){}
    
    public int addBook(Book b){}   //有事务
}
    

事物传播行为:
	REQUIRED
	NOT_SUPPORTED
	REQUIRES_NEW
	MANDATORY
	NEVER
	SUPPORTS

		@Transactional(propagation=Propagation.REQUIRED)
			如果当前有事务, 那么该方法就在当前事务中运行, 没有的话新建一个(默认)
		@Transactional(propagation=Propagation.NOT_SUPPORTED)
			当前方法不运行在事务中，方法A调用方法B，方法B会将A的事务挂起，A以非事务执行
		@Transactional(propagation=Propagation.SUPPORTS)
			方法A调用方法B，如果A有事务就以A的事务执行，如果A没有事务，那么B就会以非事务运行。
		@Transactional(propagation=Propagation.REQUIRES_NEW)
			不管是否存在事务,都创建一个新的事务,原来事务的挂起,新的执行完毕,继续执行老的事务
        @Transactional(propagation=Propagation.MANDATORY)
			必须在一个已有的事务中执行,否则抛出异常
		@Transactional(propagation=Propagation.NEVER)
			必须在一个没有的事务中执行,否则抛出异常(与Propagation.MANDATORY相反)
		@Transactional(propagation=Propagation.REQUIRED,timeout=30) //默认是30秒
			事物超时设置: 


public class aaa{
	public void a1（）{
		bbb.b1();
	
	}


}


spring隔离级别设置：
		@Transactional(propagation= Propagation.REQUIRED,timeout=30,isolation= Isolation.DEFAULT)
        public void method(){}
        
        
1、Isolation.DEFAULT（默认）
	这是默认值，表示跟连接的数据库设置的隔离级别一致。
	
2、Isolation.READ_UNCOMMITTED（未授权读取级别）
	以操作同一行数据为前提，事务可以读取到另一个事务未提交的事务记录。此隔离级别可以防止更新丢失，但不能防止脏读、不可重复读、幻读。

3、Isolation.READ_COMMITTED（授权读取级别）
	这是大多数项目采取的隔离级别(但不是MySQL默认的)。它满足了隔离的简单定义：一个事务只能看见已经提交事务所做的改变。

4、Isolation.REPEATABLE_READ（可重复读取级别）
    它确保同一事务的多个实例在并发读取数据时，会看到同样的数据行。不过理论上，这会导致幻读的问题。

5、Isolation.SERIALIZABLE（序列化级别）
提供严格的事务隔离。它要求事务序列化执行，事务只能一个接着一个地执行，不能并发执行。此隔离级别可以防止更新丢失、脏读、不可重复读、幻读。如果仅仅通过“行级锁”是无法实现事务序列化的，必须通过其他机制保证新插入的数据不会被刚执行查询操作的事务访问到，会导致性能下降。

7：自定义注解

1：定义注解：
@Target(ElementType.METHOD)			//定义该注解为方法注解
@Retention(RetentionPolicy.RUNTIME)	//运行时注解
public @interface MyAnnotation {    //自定义注解名字
	String abc();  //定义抽象方法，返回值为字符串类型
}

2：使用注解：把上面的注解名添加在接口的方法头上
	@MyAnnotation(abc="添加书籍")
	public void addBook();
3：在aop中可以获得被代理对象的方法与该方法的注解对象。
@Aspect
@Component
public class MyAdvice4{
//	@Autowired						nid		操作者	时间		操作内容
//	NodeService NodeService;
	
	@AfterReturning(pointcut="execution(* xa.woniu.mapper.*.*(..))",returning="obj")
	public void houzhi(JoinPoint jp,Object obj){
		System.out.println("后置返回值通知：");
		
		//时间;new Date();
		Date d1 = new Date();
		SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String time = sdf1.format(d1);
		
		Method targetMethod = ((MethodSignature)jp.getSignature()).getMethod();	//被代理的方法对象
		
		
		//获得该方法注解对象：注意当前Aop使用的是cglib代理还是jdk代理，如果是jdk代理，则自定义注解使用在接口方法头上，如果使用cglib代理，则自定义注解使用在实现类方法头上，原因：jdk代理的是接口，cglib代理的是实现类
		MyAnnotation r1 = targetMethod.getAnnotation(MyAnnotation.class);
		if(r1!=null) {
			String annotationName = r1.abc();
			System.out.println(time+annotationName+obj);
		}
		/* 添加mvc依赖后，获得session的对象：
		ServletRequestAttributes sraAttributes =  				(ServletRequestAttributes)RequestContextHolder.getRequestAttributes();
		HttpServletRequest request = sraAttributes.getRequest();
		HttpSession session = request.getSession();
		Userinfo u = session.getAttribute("U");
		String uname = "张三";
		System.out.println(uname+time+annotationName+obj);
		*/
	}
}

<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
<context:component-scan base-package="xa.woniu.mapper,xa.woniu.service,xa.woniu.advice">
</context:component-scan>

8：idea添加mybatis插件

见word文档

注意给java包和resources包授权，否则包路径架构是floder,不是package
	java包上右键->Mark Directory as->java  resource Root
	resources包上右键->Mark Directory as->resources Root

9：spring常用注解

Ioc:
@Component
替换成子注解：因为注解还有注释还有注释的作用，代表MVC哪一层代码的注释
	@Contolller		@Service	@Repository
DI:
@AutoWired
@Resource
@Value
@Qualifier
Aop:
@Aspect
@Before
@After
@AfterReturning
@Around
@AfterThrowing

10：springmvc：

针对控制层，视图层(页面模板)封装，对MVC进行封装。

1)基本应用

1：引入依赖：
    	<dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-webmvc</artifactId>
          <version>5.2.12.RELEASE</version>
        </dependency>
        <!--引入servlet的jar包，暂时使用，后面可以不用-->
        <dependency>
          <groupId>javax.servlet</groupId>
          <artifactId>servlet-api</artifactId>
          <version>2.5</version>
        </dependency>
		观察引入jar发现：spring_core、IOC、AOP、web都已经加载。
		
web.xml：web项目核心配置文件：tomcat启动，先读取web.xml:通常定义了servlet、filter、listener
	web.xml中定义springmvc核心控制器(前端控制器)：    DispatcherServlet
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <!--加载main/resource/spring-servlet.xml文件：为mvc做配置-->
            <param-value>classpath:spring-servlet.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>
注意DispatcherServlet类的作用：
	1：DispatcherServlet类是springmvc依赖中提供的一个Servlet，当启动服务器，tomcat就会创建DispatcherServlet对象，DispatcherServlet就会创建IOC容器(ApplicationContext对象)，也就是启动服务器，tomcat会创建DispatcherServlet对象且DispatcherServlet对象创建IOC容器(ApplicationContext对象)。
	2：纯spring项目中由我们自己创建IOC容器(ApplicationContext对象)，在Springmvc环境下，由DispatcherServlet对象创建。
	3：DispatcherServlet对象创建的IOC容器(ApplicationContext对象)，会存在application作用域中，也就是说在整个web环境中随时可用。
            

2：在main\resources新建spring-servlet.xml：可以完全代替springConfig.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"
           xsi:schemaLocation="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.xsd">
        <bean id="empMapper" class="com.woniu.mapper.EmpMapper"></bean>
</beans>
3:自定义类:com.woiu.mapper.EmpMapper类：测试IOC功能
	public static void main(String[] args) {
        ApplicationContext context = 
            new ClassPathXmlApplicationContext("spring-servlet.xml");
        EmpMapper empMapper = (EmpMapper)context.getBean("empMapper");
        empMapper.test();
    }
            
4:测试mvc的封装：springmvc针对控制层的封装：定义一个控制层类：
    com.woniu.controller.EmpController,注册在spring-servlet.xml中
package com.woniu.controller;
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 EmpController implements Controller {
    public EmpController(){
        System.out.println("EmpController对象创建了。。。。。");
    }
   	@Override
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        System.out.println("hellow springmvc");
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("/index.jsp");
		modelAndView.addObject("aaa","bbb");
        return modelAndView;
    }
}
<bean id="/empServlet.do" class="com.woniu.controller.EmpController"></bean>

5：配置tomcat并启动：浏览器访问：http://localhost:8080/test2/empServlet.do，观察控制台与页面
	要求：根据二阶段SuperServlet的代码说清楚以上的逻辑。


6：springmvc执行流程重点理解：
    1：启动服务器，加载tomcat读取web.xml文件，创建DispatcherServlet(前端控制器)对象并初始化读取参数：spring-servlet.xml，读取该文件并创建IOC容器，创建EmpController对象,名字叫做/empServlet.do。因为该bean实现了Controller接口，所以可以通过浏览器地址请求该bean，并执行handleRequest方法(原理借鉴二阶段继承SuperServlet，每次请求servlet时，一定执行doGet方法。)
    2：当客户端请求/empServlet.do(*.do)时，通过前端控制器对象DispatcherServlet，将请求转发给映射处理器
    3：映射处理器：根据请求的id与uri，获取对应要执行的方法handleRequest(原理借鉴SuperServlet的doGet方法)
    4：将handleRequest方法对象返回给前端控制器
    5：前端控制器将handleRequest方法对象发送给适配处理器：具体执行handleRequest方法，并获得返回modelAndView对象。
    6：前端控制器获得到返回的modelAndView对象，并发送给视图解析器
    7：视图解析器解析该modelAndView对象，获得转发的的具体视图(xxx.jsp)，并返回给前端控制器
    8：前端控制器获得视图对象后并返回给客户端。

2)映射处理器

手动配置映射处理器,如果不配置，则使用sprinmvc默认映射器：
	根据请求的id与uri，获取对应要执行的方法对象handleRequest
<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"></bean>

原理：
	String uri = request.getRequestURI();   "/test1/empServlet.do"
	String beanId = uri.substring(uri.lastIndexOf("/")+1,-1);empServlet
	beanId = "/"+beanid+".do";
	通过jdom技术,在spring-mvc.xml中，根据beanId获取class属性值：
	String className = "com.woniu.controller.EmpController";
	Class clazz = class.forName(className);
	Object EmpServlet = clazz.newInstance();
	Method method = clazz.getDeclaredMethod("handleRequest",HttpServletRequest.class,HttpServletResponse.class);

3)适配处理器

手动配置适配处理器,如果不配置，则使用sprinmvc默认映射器：
	具体执行handleRequest方法，并返回modelAndView对象。
<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"></bean>
原理：
	ModelAndView modelAndView = (ModelAndView)method.invoke(EmpServlet,request,response);

4)视图解析器

手动配置视图解析器,如果不配置，则使用sprinmvc默认映射器：
	解析modelAndView对象，获得转发的的具体视图对象与参数，并返回给前端控制器
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
	<property name="prefix" value="/"></property>
	<property name="suffix" value=".jsp"></property>
</bean>
	注意：配置了视图解析器之后，modelAndView对象的前缀与后缀可以简写。
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("index");
        modelAndView.addObject("aaa","bbb");
原理：
	String viewName = modelAndView.getViewName();     //index
	viewName = "/"+viewName+".jsp";
	request.setAttribute("aaa",modelAndView.getObject("aaa"));		
	交给前端控制器后执行：	request.getRequestDispatcher().forward(request,response)

5)目的与作用

不同的对象负责不同的功能：
	符合单一职责：将一个复杂的任务拆分成若干的小任务，每个对象完成单一的任务。
	解耦：互不影响
	增强复杂的任务的扩展性，只需要考虑哪个小任务需要扩展。
	
映射处理器：根据请求的id与uri，获取对应要执行的方法对象handleRequest
适配处理器：具体执行handleRequest方法，并返回modelAndView对象。
视图解析器：解析modelAndView对象，获得转发的的具体视图对象与参数，并返回给前端控制器

6)注解映射处理器和注解适配处理器

将BeanName映射处理器
<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"></bean>
替换为：RequestMapping注解映射处理器
<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"></bean>


将简单适配处理器
<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"></bean>
替换为：RequestMappingHandlerAdapter注解适配处理器
<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"></bean>

视图解析器不变
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/"></property>
        <property name="suffix" value=".jsp"></property>
</bean>


映射处理器和适配处理器就可以识别注解，并不需要实现Controller接口，且可以根据注解获得自定义方法执行。
	@Controller
	@RequestMapping("/emp")
	

注意
	<!--引入以上两个注解映射器和适配器，还额外包括数据自动转换json功能-->
    <mvc:annotation-driven></mvc:annotation-driven>
    <context:component-scan base-package="com.woniu.controller"></context:component-scan>

7)控制层代码

@Controller
@RequestMapping("/emp")
public class EmpController{
    public EmpController(){
        System.out.println("EmpController对象创建了。。。。。");
    }
    @RequestMapping("/test.do")
    public ModelAndView xxx() {
        System.out.println("hellow springmvc");
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("/index");
        modelAndView.addObject("aaa","bbb");
        return modelAndView;
    }
    @RequestMapping("/test2.do")
    public ModelAndView test2() throws Exception {
        System.out.println("hellow springmvc");
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("redirect:/test/test.jsp");
        return modelAndView;
    }
    注意：redirect：重定向：视图解析器失效，需要自己写路径：/的作用：从webapp根目录找路径
}

@RequestMapping("/emp")		定义类请求路径
@GetMapping("/regist.do")	通常定义方法的请求路径：该方法只能接受get请求方式
@PostMapping("/regist.do")	通常定义方法的请求路径：该方法只能接受post请求方式

8)接收参数

	@RequestMapping("/test1.do")
    public ModelAndView t1(HttpServletRequest request,HttpServletResponse response){
        String a = request.getParameter("a");
        System.out.println("hellow springmvc"+a);
        return null;
    }
    @RequestMapping("/test2.do")
    public ModelAndView t2(Emp emp,String a,int b){
        System.out.println("hellow springmvc"+emp+a+b);
        return null;
    }
    @RequestMapping("/test3.do")
    public ModelAndView t3(@RequestParam(value = "aaa",required = true,defaultValue = "bbb") String sss){
        System.out.println("hellow springmvc"+s);
        return null;
    }
    @RequestParam：定义接收实参参数的要求：
    	value = "aaa"：接收实参名为aaa参数复制给形参sss
    	required = true(默认)：实参中必须包含参数aaa，否则抛异常。
    	defaultValue = "bbb"：设置required = false，且实参中没有传递aaa的参数时，设置sss="bbb"
    
    
注意：
	1：Springmvc将请求参数封装，执行控制层代码之前先进入默认拦截器，在该默认拦截器中接收参数并赋值，要求形参实参名字相同。
	2：如果没有实参，则形参结果为null
	3：如果形参为基本数据类型，则必须有实参，否则抛异常。
	4：@RequestBody @PathVariable为异步请求时接收参数时使用，后面异步请求讲解

9)乱码处理

添加过滤器：springmvc提供了乱码处理的过滤器

<filter>
    <filter-name>springFilter</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>springFilter</filter-name>
    <url-pattern>*.do</url-pattern>
  </filter-mapping>
  
注意写在servlet之前

11:ssm整合

1)依赖

<dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <!--springIOC,AOP,MVC-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.2.12.RELEASE</version>
    </dependency>
    <!--切面包-->
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjrt</artifactId>
      <version>1.9.7</version>
    </dependency>
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.9.7</version>
    </dependency>

    <!--servlet-->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <version>2.5</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>
    <dependency>
      <groupId>com.github.pagehelper</groupId>
      <artifactId>pagehelper</artifactId>
      <version>5.1.8</version>
    </dependency>

    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>8.0.27</version>
    </dependency>
  <!--springjdbc-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.2.12.RELEASE</version>
    </dependency>
</dependencies>

2)web.xml

<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:spring-mvc.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>

3):spring-mvc.xml

 1：定义映射处理器，适配处理器，视图解析器
 	<!--创建了注解映射处理器，注解适配处理器，处理json-->
    <mvc:annotation-driven></mvc:annotation-driven>
    <!--创建视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/"></property>
        <property name="suffix" value=".jsp"></property>
    </bean>

2：整合mybatis：
		<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/shop?serverTimezone=GMT&amp;useSSL=false"></property>
        <property name="username" value="root"></property>
        <property name="password" value="123456"></property>
    </bean>
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <property name="configLocation" value="classpath:MyBatisConfig.xml"></property>
    </bean>
    <bean  class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.woniu.mapper"></property>
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>
    </bean>
    
3：事务处理：
	<!--创建事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!--启动注解式事务-->
    <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
    <!--注解开发扫描包-->
    <context:component-scan base-package="com.woniu.*"></context:component-scan>
    <!--自定义切面注解：完成日志-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

4)mybatisConfig.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>
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/><!-- 控制台显示mybatis日志信息 -->
    </settings>
    <plugins>
        <plugin interceptor="com.github.pagehelper.PageInterceptor" >
            <property name="reasonable" value="true"/>
        </plugin>
    </plugins>
    <mappers>
        <package name="com.woniu.mapper"/>
    </mappers>
</configuration>


逆向工程：注意给java包和resources包授权，否则包路径架构是floder,不是package
	java包上右键->Mark Directory as->java  resource Root
	resources包上右键->Mark Directory as->resources Root

5)业务层

@Service
@Transactional
public class UserinfoService {
    @Autowired
    private UserinfoDao userinfoDao;
    public boolean regist(Userinfo u){
       return userinfoDao.insert(u) > 0;
    }
}

6)控制层

@Controller
@RequestMapping("/userinfo")
public class UserinfoController {
    @Autowired
    private UserinfoService userinfoService;
    @RequestMapping("/regist.do")
    public ModelAndView regist(Userinfo u){
        boolean b = userinfoService.regist(u);
        System.out.println(b);
        return null;
    }
}

7)请求乱码

<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>
</filter>
<filter-mapping>
			<filter-name>characterEncodingFilter</filter-name>
			<url-pattern>/*</url-pattern>
</filter-mapping>

注意：
	1：springmvc提供该乱码过滤器，与之前自己手写过滤器作用完全一致，但是maven_web项目中需要将过滤器定义在sevlet之前。
	2：客户端jsp/html需要定义编码格式：index.jsp没有定义
		<%@ page contentType="text/html;charset=UTF-8" isELIgnored="false" language="java" %>

8)上传

1：添加依赖：
	<dependency>
      <groupId>commons-fileupload</groupId>
      <artifactId>commons-fileupload</artifactId>
      <version>1.3.3</version>
    </dependency>

2：<form action="/updateBookByBid.do" method="post" enctype="multipart/form-data">
		<input type="hidden" name="bid" value="${b.bid }"><br>
		书名：<input type="text" name="bname" value="${b.bname }"><br>
		图片：<input type="file" name="f1" multiple="multiple"><br>
		<input type="submit">
	</form>
3：定义上传文件解析器对象
<!-- 定义文件解析器对象 -->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    			<!--限制上传文件的最大尺寸，单位为字节-->
				<property name="maxUploadSize" value="104857600" />
    			<!--读取文件到内存中最大的字节数(缓存)，默认是1024，单位为字节-->
				<property name="maxInMemorySize" value="4096" />
				<property name="defaultEncoding" value="UTF-8"></property>
</bean>
4：servlet：
            
 MultipartFile：springmvc提供的文件上传工具组件对象，注意@RequestParam("f1")的用法：上传域名称
public String updateBook(HttpServletRequest request,Book k,@RequestParam("f1") MultipartFile[] files){
      String path = request.getRealPath("/");	
      String path2 = "/img/1.png";
      System.out.println(files.length);
      for(int i=0;i<files.length;i++){
           MultipartFile f1 = files[i];   MultipartFile:封装了上传的文件对象
           if(f1.isEmpty()){
              continue;  
           }
           String fileName = f1.getOriginalFilename(); //获得上传文件名
fileName = new Date().getTime()+"_"+new Random().nextInt(100)+fileName.substring(fileName.lastIndexOf("."));
				path2 = "img/"+fileName;
           File f2 = new File(path1+path2);
           f1.transferTo(f2);  //f1另存为f2
     }
}

12：异步请求

引入：vue.js和axios.js

springmvc可以根据注解自动将返回对象转成json或者字符串，需要引入依赖：
	<dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>2.15.0</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.15.0</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-annotations</artifactId>
      <version>2.15.0</version>
    </dependency>
@ResponseBody：方法注解，取消视图解析器作用，将返回值自动转成json对象或者返回字符串
@RestController：控制层类注解，作用：@Controller+@ResponseBody

1：请求测试1

test1(){
            axios({
                baseURL:"http://localhost:8080/xxx",
                url:"/userinfo/t1.do",
                method:"post",
                params:{a:"aaa",b:"bbb"},		//请求参数以请求头拼接字符串方式传给服务器
                responseType:"text",
                //请求参数以请求请求方式传给服务器，请求体只能传递一个json对象，服务器控制层必须以一个对象键名包含如下键名的对象才能接收该参数
                data:{a:"xxx",b:"yyy"}							
            }).then(response=>{
                 console.log(response.data);
            });
        }

	@ResponseBody				
    @RequestMapping("/t1.do")
    public String t1(String a,String b){
        System.out.println(a+"   "+b);
        return "abc";
    }

2：请求测试2：

test2(){
	//将参数以请求头的方式传参
	axios.get("http://localhost:8080/xxx/userinfo/t2.do",{params:{a:"aaa",b:"bbb",c:"ccc"}})
	.then(response=>{
                 console.log(response.data);
     });
}

3：请求测试3

test3(){
    //将参数以请求体的方式传参
	axios.get("http://localhost:8080/xxx/userinfo/t3.do",		
		{a:"aaa",b:"bbb",c:"ccc"}).then(response=>{
        console.log(response.data);
    });
}

	@ResponseBody
    @RequestMapping("/t3.do")
    public String t3(String a,String b,String c){		//接收不到参数
        System.out.println(a+"   "+b+"   "+c);
        return "abc";
    }

4：请求测试4

    //post请求会将请求参数转成json对象，放在请求体中传给服务器，请求体中只能传递一个对象。
    //控制层参数可以使用@RequestBody参数注解标识从请求体中接受参数
    test4(){
        axios.post("http://localhost:8080/xxx/userinfo/t4.do",this.u)
        .then(response=>{
            console.log("xxxx"+response.data.uacc);
        });
    }

	@ResponseBody
    @RequestMapping("/t4.do")
    public Userinfo t4(Userinfo u){
    	System.out.println(u);		接收不到参数，参数需要使用@RequestBody标注
        u.setUacc("aaa");
        u.setUpwd("bbb");
        return u;
    }

5：请求测试5

//传参语法没有问题，但是控制层只能有一个有一个参数对象，键名是u和str1的对象来接收
        test5(){
            axios.post("http://localhost:8080/xxx/userinfo/t5.do", {u:this.u,str1:"sss"})
                .then(response=>{
                    console.log("xxxx"+response.data.uacc);
                });
        }
        
    @ResponseBody
    @RequestMapping("/t5.do")
    public Userinfo t5(Userinfo u,String str1){		接收不到参数
        System.out.println(str1+"   "+u);
        u.setUacc("aaa");
        u.setUpwd("bbb");
        return u;
    }

6：请求测试6

test6(){
            axios.post("http://localhost:8080/xxx/userinfo/t6.do?str1=aaa",this.u)
                .then(response=>{
                    console.log("xxxx"+response.data.uacc);
                });
}

	@ResponseBody
    @RequestMapping("/t6.do")
    public Userinfo t6(@RequestBody Userinfo u,String str1){
        System.out.println(str1+"   "+u);
        u.setUacc("aaa");
        u.setUpwd("bbb");
        return u;
    }

7：请求测试7

			axios({
                baseURL:"http://localhost:8080/xxx",
                url:"/userinfo/t7.do",
                method:"post",
                params:{a:"aaa",b:"bbb"},  //请求头传参
                data:this.u,                //请求体传参
                responseType:"text",
            }).then(response=>{
                console.log(response.data);
            });
            
            @ResponseBody
            @RequestMapping("/t7.do")
            public Userinfo t7(@RequestBody Userinfo u, String a, String b){
                System.out.println(a+"   "+b+"   "+u);
                u.setUacc("aaa");
                u.setUpwd("bbb");
                return u;
            }

8：RestFul

异步请求路径风格：
	http://localhost:8080/ssm1/goods/goods/1		
	http://localhost:8080/ssm1/goods/goods

1：将DispatcherServlet请求方式的*.do改为/,意味着所有请求都进入前端控制器检查(包括web资源文件)
2：导致问题：所有的web静态资源/.css/.js/.img路径全部失效，只有.jsp不失效。
3：所以springmvc配置<mvc:default-servlet-handler></mvc:default-servlet-handler>
默认servlet映射处理器：当请求资源文件不能够通过注解映射器映射对象时，使用默认servlet映射处理器(专门针对当前映射器映射失败后：使用默认servlet方式加载web静态资源)

web.xml:
<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:spring-mvc.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>

2:springmvc.xml添加：
	<mvc:default-servlet-handler></mvc:default-servlet-handler>
	
3：请求方式：
	test8(){
            axios.get("http://localhost:8080/xxx/userinfo/t8/abc").then(
                response=>{
                    console.log(response.data);
                }
            );
      }
4：控制层：
@ResponseBody
    @RequestMapping("/t8/{abc}")
    public String t8(@PathVariable("abc") String xxx){
        System.out.println(xxx);
        return null;
    }
    
@PathVariable：声明请求路径中实参赋值给形参

9：RestFul请求方式：

全称：Representational State Transfer(表述性状态转移)。

RESTful架构是对MVC架构改进后所形成的一种架构，通过使用事先定义好的接口与不同的服务联系起来。在RESTful架构中，浏览器使用GET，POST，DELETE和PUT四种请求方式分别对指定的URL资源进行增删改查操作。因此，RESTFUL是通过URI实现对资源的管理及访问，具有扩展性强、结构清晰的特点。

特点：请求路径不以.xxx结束，且可以根据请求方式来实现不同的功能

1：get、post请求方式刻印在开发人员的脑海中几十年
2：原来我们请求服务器通常：
	http://localhost:8080/ssm1/goods/addGoods.do			post请求方式
	http://localhost:8080/ssm1/goods/updateGoods.do			post请求方式
	http://localhost:8080/ssm1/goods/delGoods.do?gid=1		get请求方式
	http://localhost:8080/ssm1/goods/selAllGoods.do			get请求方式
	http://localhost:8080/ssm1/goods/selGoodsByGid.do?gid=1	get请求方式
	
3：RestFul请求风格：通过请求地址与请求方式双重决定执行什么方法：
	http://localhost:8080/ssm1/goods/111/goods	
	http://localhost:8080/ssm1/goods/goods
    
4：RestFul请求风格的请求方式：GET\POST\PUT\DELETE:查、增、改、删
		aaa1(){
            axios.get("http://localhost:8080/xxx/userinfo/selById/"+this.uid).then(
                response=>{
                    console.log(response.data);
                }
            );
        },
        aaa2(){
            axios.post("http://localhost:8080/xxx/userinfo/add",this.u).then(
                response=>{
                    console.log(response.data);
                }
            );
        },
        aaa3(){
            axios.put("http://localhost:8080/xxx/userinfo/update",this.u).then(
                response=>{
                    console.log(response.data);
                }
            );
        },
        aaa4(){
            var id = "1,2,3,4,";
            axios.delete("http://localhost:8080/xxx/userinfo/del/"+id).then(
                response=>{
                    console.log(response.data);
                }
            );
        }
        
        
    @ResponseBody
    @RequestMapping(value = "/userinfo/selById/{id1}",method = RequestMethod.GET)
    //定义方法的请求路径与请求方式：双重匹配才能执行该方法。
    public String selById(@PathVariable("id1") Integer id){
        System.out.println(id);
        return "ok";
    }

    @ResponseBody
    @RequestMapping(value = "/userinfo/add",method = RequestMethod.POST)
    public Userinfo add(@RequestBody Userinfo u){
        System.out.println(u);
        return u;
    }

    @ResponseBody
    @RequestMapping(value = "/userinfo/update",method = RequestMethod.PUT)
    public Userinfo update(@RequestBody Userinfo u){
        System.out.println(u);
        return u;
    }

    @ResponseBody
    @RequestMapping(value = "/userinfo/del/{ids}",method = RequestMethod.DELETE)
    public String del(@PathVariable("ids")  String ids){
        System.out.println(ids);
        return "ok";
    }

10：异步上传

前端：
	var fd = new FormData();
			for(var i=0;i<obj.files.length;i++){
				fd.append("ff",obj.files[i]);
			}
			axios({
				baseURL:"http://localhost:8080/ssm1",
				url:"/userinfo/upload",
				headers:{'Content-Type':'multipart/form-data'},
				data:fd,
				method:"post",
				responseType:"text"
			}).then(response=>{
				console.log(response.data)
				this.u.uphoto = response.data;
			});
			
后端：
	@RequestMapping(value = "/userinfo/upload",method = RequestMethod.POST)
    public String upload(HttpServletRequest request,@RequestBody @RequestParam("ff") MultipartFile[] multipartFile){
        System.out.println("xxxxxxxxxxxxxxxxxxx"+multipartFile);
        String path2 = "";
        /*try{
                if(!multipartFile.isEmpty()){
                    String path1 = request.getRealPath("/");
                    path2 = "upload/" + new Date().getTime() + multipartFile.getOriginalFilename().substring(multipartFile.getOriginalFilename().lastIndexOf("."));
                    File f1 = new File(path1 + path2);
                    multipartFile.transferTo(f1);
                }

        }catch(Exception e){
            e.printStackTrace();
        }*/
        return path2;

    }

13：拦截器：

原理是AOP，可以执行在servlet之前或者servlet之后且view之前或者view之后执行。

定义方式1：实现HandlerInterceptor接口
	public class Interceptor1 implements HandlerInterceptor{
        @Override
        public void afterCompletion(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, Exception arg3)
                throws Exception {
            System.out.println("jsp之后执行该拦截器该方法");
            System.out.println("handler:当次请求的servlet="+arg2);
            System.out.println("ex:当次请求发生的异常对象"+ex);
        }

        @Override
        public void postHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, ModelAndView arg3)
                throws Exception {
            System.out.println("servlet之后，jsp之前执行拦截器方法");
            System.out.println("arg2:当前servlet方法对象"+arg2);
            System.out.println("modelAndView:请求的模型视图对象"+modelAndView);
        }

        @Override
        public boolean preHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2) throws Exception {
            System.out.println("servlet之前执行该拦截器方法");
            System.out.println("arg2:当前servlet方法对象"+arg2);
            return false;    //是否执行责任链(是否放行)
        }

    }


定义方式2：继承HandlerInterceptorAdapter类，重写自己需要的方法。
public class Interceptor3 extends HandlerInterceptorAdapter{
	
	@Override
	public boolean preHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2) throws Exception {
		HandlerMethod handlerMethod = (HandlerMethod)handler;
        Method method = handlerMethod.getMethod();
        System.out.println(method.getName());
		return true;
	}
}


spring-servlet.xml文件：定义该拦截器
    	1：定义在<mvc:interceptors>的根目录中的拦截器拦截所有servlet路径。	
<mvc:interceptors>
			<bean id="interceptor1" class="xa.woniu.interceptor.Interceptor1"></bean>
</mvc:interceptors>
    
		2：<mvc:interceptors>标签中可以定义<mvc:interceptor>标签，
            <mvc:interceptor>标签中定义的拦截器对象，只针对<mvc:mapping>中定义的路径。
           <mvc:interceptors>根目录定义的拦截器bean，针对所有控制器

<mvc:interceptors>
			<mvc:interceptor>
				<mvc:mapping path="/login.do"/>
				<bean id="interceptor2" class="xa.woniu.interceptor.Interceptor2"></bean> 
			</mvc:interceptor>
			<bean id="interceptor1" class="xa.woniu.interceptor.Interceptor1"></bean>
</mvc:interceptors>

14：常用注解

类注解：
@Configuration：定义bean对象的注解，通常与@Bean注解配合使用
	子类注解：@Component：定义bean对象的注解，通常定义工具类对象时使用。
    	子类注解：
    		@Controller：定义bean对象的注解，通常给控制层定义bean
    		@RestController：定义bean对象的注解，通常给控制层定义bean，会自动把返回值转成json
    		@Service：定义bean对象的注解，通常给业务层定义bean
    		@Repository:定义bean对象的注解，通常给持久层定义bean
            @Aspect：定义切面
			@Transactional：事务注解
   
方法注解：
@RequestMapping:定义该方法的请求路径
@PostMapping:定义该方法的请求路径
@GetMapping:定义该方法的请求路径
@DeleteMapping:定义该方法的请求路径
@PutMapping:定义该方法的请求路径
@ResponseBody：异步请求注解：定义该方法为异步请求
@Before  切面方法注解	前置通知
@After	后置通知
@AfterReturning 返回通知
@AfterThrowing	异常通知
@Around	环绕通知
@Bean:执行该方法，创建对象，通常该方法返回一个对象被容器管理。

参数注解：
@RequestParam:参数绑定注解，
@RequesteBody：从请求体中接收参数
@pathvariable：RestFul风格请求路径接收参数

最后更新于2年前

hashtag1：spring框架的功能：

hashtag2：spring框架优点：

hashtag3：IOC：控制反转：

hashtaga：IOC容器创建对象

hashtag1):方式1：构造器实例化

hashtag2):方式2：静态工厂模式

hashtag3):方式3：实例工厂模式

hashtag4):方式4：注解方式

hashtagb：bean的作用域：

hashtagc：IOC的父接口：

hashtagd：DI：依赖注入：

hashtage：FactoryBean与BeanFactory：

hashtag1)：FactoryBean：

hashtag2)：BeanFactory

hashtag3)：区别：

hashtag总结：

hashtag4：复习代理的作用

hashtag5：AOP:面向切面编程：

hashtag6：整合mybatis

hashtag6：事务处理：

hashtag7：自定义注解

hashtag8：idea添加mybatis插件

hashtag9：spring常用注解

hashtag10：springmvc：

hashtag1)基本应用

hashtag2)映射处理器

hashtag3)适配处理器

hashtag4)视图解析器

hashtag5)目的与作用

hashtag6)注解映射处理器和注解适配处理器

hashtag7)控制层代码

hashtag8)接收参数

hashtag9)乱码处理

hashtag11:ssm整合

hashtag1)依赖

hashtag2)web.xml

hashtag3):spring-mvc.xml

hashtag4)mybatisConfig.xml

hashtag5)业务层

hashtag6)控制层

hashtag7)请求乱码

hashtag8)上传

hashtag12：异步请求

hashtag1：请求测试1

hashtag2：请求测试2：

hashtag3：请求测试3

hashtag4：请求测试4

hashtag5：请求测试5

hashtag6：请求测试6

hashtag7：请求测试7

hashtag8：RestFul

hashtag9：RestFul请求方式：

hashtag10：异步上传

hashtag13：拦截器：

hashtag14：常用注解