@讲下SpringMvc的执行流程@

       系统启动的时候根据配置文件创建spring的容器, 首先是发送http请求到核心控制器disPatherServlet，spring容器通过映射器去寻找业务控制器，
使用适配器找到相应的业务类，在进业务类时进行数据封装，在封装前可能会涉及到类型转换，执行完业务类后使用ModelAndView进行视图转发，数据放在model中，用map传递数据进行页面显示

spring是开源的轻量级一站式框架

 1、开源的
 2、轻量级
3、一站式

[plain] 
view plain
 copy

1. spring在j2ee三层结构中，每一层都提供不同的解决技术  
2. （1）web层：springmvc  
3. （2）service层：spring的ioc  
4. （3）dao层：spring的jdbcTemplate  

spring的IOC和DI操作

 ioc：控制反转–>底层技术{ xml配置文件，dom4j解析xml，工厂设计模式，反射}

 1、把对象的创建交给spring进行管理
 2、ioc操作两种方式:
  （1）ioc的配置文件方式（掌握）
     bean的实例化（三种方式）

    ①无参构造方法实例化（重点）

[html] 
view plain
 copy

1. <bean id=”user”class=”com.yb.User”></bean>  

[html] 
view plain
 copy

1. bean标签常用属性：  
2.     id属性：根据id值得到配置对象，不能包含特殊字符。  
3.     class属性：创建所在类的全路径。  
4.     name属性：功能和id一样，但能包含特殊字符。  
5.     scope属性：（  
6.     singleton：默认值（缺省值），单例  
7.         prototype：多例  
8.         request：创建对象把对象放到request域里面  
9.         session：创建对象把对象放到session域里面  
10.         globalSession：创建对象把对象放到globalSession里面  
11.     ）  

 
 
 
 ②使用静态工厂创建（了解）

   ③使用实例工厂创建（了解）

 （2）ioc注解方式注入（重点）

[html] 
view plain
 copy

1. <!– 扫描属性上面的注解（被下面的扫描方式取代） –>  
2. <context:annotation-config></context:annotation-config>  
3. <!– 到包里面扫描：类、方法、属性上面的注释 –>  
4. <!– 若要扫描com.yb.entity、com.yb.dao …里面的注解可写成com.yb–>  
5. <context:component-scan base-package=“com.yb”></context:component-scan>  

 
 在创建对象的类上面使用注解实现


 
 
 ①@Component 衍生出下面三个注解 用法相同

 ②@Controller ：WEB层

 ③@Service ：业务层

 ④@Repository 持久层

[java] 
view plain
 copy

1. @Component(value=“user”)  
2. public class User {}  

  创建对象是多实例还是单实例

[java] 
view plain
 copy

1. @Component(value=“user”)  
2. @Scope(value=“prototype”)  
3. public class User {}  

DI：属性注入

 属性注入四种种方式： –>spring支持前三种注入方式

  1、set方法注入（重点）
 

[html] 
view plain
 copy

1. <bean id=“user” class=“com.yb.User”>  
2. <property name=“name” value=“youngboy”></property>  
3. <!– 对象注入 –>  
4. <property name=“men” ref=“person”></property>  
5. <!– 复杂类型注入 –>  
6. <!– 数组 –>  
7. <property name=“arrs”>  
8. <list>  
9. <value>小王</value>  
10. <value>小马</value>  
11. <value>小宋</value>  
12. </list>  
13. </property>     
14. <!– list –>  
15. <property name=“list”>   
16. <list>  
17. <value>小奥</value>  
18. <value>小金</value>  
19. <value>小普</value>  
20. </list>             
21. </property>         
22. <!– map –>  
23. <property name=“map”>  
24. <map>  
25. <entry key=“aa” value=“lucy”></entry>  
26. <entry key=“bb” value=“mary”></entry>  
27. <entry key=“cc” value=“tom”></entry>   
28. </map>  
29. </property>         
30. <!– properties –>  
31. <property name=“properties”>  
32. <props>  
33. <prop key=“driverclass”>com.mysql.jdbc.Driver</prop>  
34. <prop key=“username”>root</prop>  
35. </props>  
36. </property>  
37. </bean>  

   2、构造方法注入(掌握)

[html] 
view plain
 copy

1. <bean id=“user” class=“com.yb.User”>  
2. <!– 简单类型注入 –>  
3. <constructor-arg name=“name” value=“youngboy”></constructor-arg>  
4. <!– 对象注入 –>  
5. <constructor-arg name=“man” ref=“person”></constructor-arg>  
6. <!– 复杂类型注入 –>  
7. <constructor-arg name=“arrs”>  
8. <list>  
9. <value>小王</value>  
10. <value>小马</value>  
11. <value>小宋</value>  
12. </list>  
13. <!– list map properties 同上set注入 –>  
14. </constructor-arg>  
15. </bean>  

 
 
 3、p名称空间注入（了解）

 
 
 4、接口注入（了解）

 
 属性注解注入（重点）

  两个注解方式：
@Autowired @Resource(name=”xxx”)

[html] 
view plain
 copy

1. <span class=“space” style=“text-indent:2em;line-height:inherit;”><!– 扫描属性上面的注解（被下面的扫描方式取代） –>  
2. <context:annotation-config></context:annotation-config>  
3. <!– 到包里面扫描：类、方法、属性上面的注释 –>  
4. <!– 若要扫描com.yb.entity、com.yb.dao …里面的注解可写成com.yb–>  
5. <context:component-scan base-package=“com.yb”></context:component-scan></span>  

[html] 
view plain
 copy

1. @Autowired  
2. private Integer userId;  
3. @Resource(name=“username”)  
4. private String username;  

Spring的aop操作（详情）

 AOP操作术语

[html] 
view plain
 copy

1. Joinpoint(连接点): 类里面可以被增强的方法，这些方法称为连接点  
2. Pointcut(切入点):所谓切入点是指我们要对哪些Joinpoint进行拦截的定义.  
3. Advice(通知/增强):所谓通知是指拦截到Joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能)  
4. Aspect(切面): 是切入点和通知（引介）的结合  
5. Introduction(引介):引介是一种特殊的通知在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field.  
6. Target(目标对象):代理的目标对象(要增强的类)  
7. Weaving(织入):是把增强应用到目标的过程.  
8.     把advice 应用到 target的过程  
9. Proxy（代理）:一个类被AOP织入增强后，就产生一个结果代理类  

使用表达式配置切入点 
[html] 
view plain
 copy

1. 1 切入点：实际增强的方法  
2.   
3. 2 常用的表达式  
4. execution(<访问修饰符>?<返回类型><方法名>(<参数>)<异常>)  
5. （1）execution(* com.aop.Book.add(..))  
6. （2）execution(* com.aop.Book.*(..))  
7. （3）execution(* *.*(..))  
8. （4） 匹配所有save开头的方法 execution(* save*(..))  

[html] 
view plain
 copy

1. <!– 开启aop操作 –>  
2. <aop:aspectj-autoproxy></aop:aspectj-autoproxy>  

[java] 
view plain
 copy

1. @Aspect  
2. public class LoginController {  
3.     @Before(value = “execution(* com.aop.Test.*(..))”)  
4.     public void test() {  
5.           
6.     }  
7. }  

spring的事务管理

 第一步：配置事务管理器

[html] 
view plain
 copy

1. <!– 事务管理 –>  
2. <bean id=“transactionManager” class=“org.springframework.jdbc.datasource.DataSourceTransactionManager”  
3.     p:dataSource-ref=“dataSource” />  
4. <tx:advice id=“txAdvice”>  
5.     <tx:attributes>  
6.         <!– 对update，delete，insert开头的方法进行事务管理，只要遇到异常就回滚 –>  
7.         <tx:method name=“update*” propagation=“REQUIED” rollback-for=“java.lang.Throwable” />  
8.         <tx:method name=“delete*” propagation=“REQUIED” rollback-for=“java.lang.Throwable” />  
9.         <tx:method name=“insert*” propagation=“REQUIED” rollback-for=“java.lang.Throwable” />  
10.         <!– 对查询数据库进行只读，提高数据库性能 –>  
11.         <tx:method name=“select*” read-only=“true” />  
12.         <tx:method name=“count*” read-only=“true” />  
13.         <!– 对其他的方法进行默认处理 –>  
14.         <tx:method name=“*” />  
15.     </tx:attributes>  
16. </tx:advice>  
17. <!– 事务 aop 配置 –>  
18. <aop:config>  
19.     <aop:pointcut expression=“execution(* com.yb.service.*.*(..))” id=“serviceMethods” />  
20.     <aop:advisor advice-ref=“txAdvice” pointcut-ref=“serviceMethods” />  
21. </aop:config>  

 第二步：配置事务注解
[html] 
view plain
 copy

1. <tx:annotation-driven transaction-manager=“transactionManager”/>  

第三步：在要使用事务的方法所在类上面添加注解  
[java] 
view plain
 copy

1. @Transactional  
2. public class LoginService {}  

       系统启动的时候根据配置文件创建spring的容器, 首先是发送http请求到核心控制器disPatherServlet，spring容器通过映射器去寻找业务控制器，
使用适配器找到相应的业务类，在进业务类时进行数据封装，在封装前可能会涉及到类型转换，执行完业务类后使用ModelAndView进行视图转发，数据放在model中，用map传递数据进行页面显示