[Java] Spring 学习笔记
Spring3.0 面向抽象(接口)编程
用面向对象的思维考虑问题 ： 第一步【先考虑实体类】
1, 设计东西 ：需要先考虑实体类。
JUDE 一个 类似 UML 的工具。
2, 设计 ：图
UserDAO ： 负责和不同的数据库打交道。等价于它直接屏蔽了数据库。(是interface)
UserService : 用户管理服务层。 其中有 private UserDAO userDAO; 成员变量
对外公开的是业务逻辑，以后比如认证，权限...。
UserDAOImpl implements UserDAO
UserDAOImpl 可以分为 MysqlImpl, OracleImpl, ... 面向抽象编程(好处灵活)
装修房子用壁纸 ： 用符合国家生产规格的壁纸。 (尚学堂， 夏学堂生产的)
马士兵 ：10 年买起房子.
3, 各种 DAO, DAO 太多， TeacherDAO, ..., 将其写到配置文件中去。
4, Spring , xml配置文件 项目驱动是最快的学习方式。
(1), jdom学习 ：读取 xml 文件. google 搜索 例子 ：class Sample1.
dom4j 比 jdom 要强大一些。
以前马老师用的 JUnit, 这块你不要害怕，藐视它就可以，有它的视频。
5, spring 的核心，在于自动装配。
可以在配置文件中，将很多类的关系设计好。
beans.xml
<beans>
<bean id="u" class="com.bjsxt.dao.impl.UserDAOImpl"/>
<bean id="userService" class="com.bjsxt.service.UserService">
<property name="userDAO" bean="u"/>
<!-- 代表 userService 中有一个 setUserDAO 的方法，也就间接代表 其中有一个 userDAO 成员变量，其值初始化为 id 为 u 的 class。-->
</bean>
</beans>
一个类 UserService 里面 一个属性，可以给你指定好。在它生成的时候，就可以指定。
就看你配置文件怎么写。
6, 什么是 IOC (DI), 有什么好处？
(1), 把自己 new 的东西改为容器提供
(a), 初始化具体值
(b), 装配
(2), 好处, 灵活配置
7, Spring 的两大核心 ： (1) IOC (2) AOP
8, Spring 介绍 。 读 Spring API
问 ：spring3.1 这个 spring.jar 怎么不在 dist 文件夹里,是不是还要额外下载jar包?
答 ：spring3.0以上已经没有提供完整的spring包了，按功能模块被分解成了，实际开发时，选择你需要的包即可，core，beans，context，
在使用web开发中一般都需要被加入，如果你实际应用使用了aop等，这些包也要被加入。
9, // dependency injection - 依赖注入 示例程序中, UserService, DAO 都依赖于 容器的 注入
/* inversion of control 什么是控制反转？
(1), Service 成员 userDAO 控制在容器手里了，不用自己new实现。反转到容器那里去了！
(2), 原来编程控制的是实现，现在是接口,是抽象, 反转到抽象
(3), 你控制的是接口，而不是整个实现了！原来控制在自己手里，现在控制在别人的容器手里了。 “控制反转”
*/
@(1), 指定 XML, catalog 书写规范与提示 Spring_09 自动提示 马士兵.avi
注入类型
Spring_0300_IOC_Injection_Type
setter（重要）
构造方法（可以忘记）
接口注入（可以忘记）
@(2), 以上讲解的都是 setter 注入
11, annotation
@(1), 普通 java 文件 中 @overvide 编译期间
Annotation-based container configuration
<?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-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">
<context:annotation-config/>
</beans>
---------------------------------------------------------------------------------------
(The implicitly registered post-processors include
AutowiredAnnotationBeanPostProcessor, CommonAnnotationBeanPostProcessor,
PersistenceAnnotationBeanPostProcessor, RequiredAnnotationBeanPostProcessor.)
----------------------------------------------------------------------------------------
http://www.springframework.org/schema/beans/spring-beans-3.1.xsd 这个文件相当于当前 xml 文件的命名空间
xmlns = xml namespace xmlns:context="http://www.springframework.org/schema/context" 命名空间
代表这个xml文件，以context开头的对应的东西到哪里找。
对应的能够写的内容context="http://www.springframework.org/schema/context" 到哪里去找
@2, xsd 文件 是元数据, 一般称之为 xml 的语法。
12, JSR-250
JCP (google网址) 指定 java 的新标准
annotation 开发效率高
13, AOP
@1, 慎用继承 (因为继承直接就写死了！)
经常组合代替了继承，组合灵活性更高！
@2, Spring 解决了单例的问题
动态代理 jdk 如果想产生动态代理，那么这个类就需要实现一个接口，没有implements接口的类，JDK是给它产生不了动态代理的。
jdk proxy invocationhander
14,
UserDAO userDAO = new UserDAOImpl();
LogInterceptor li = new LogInterceptor();
li.setTarget(userDAO);
UserDAO userDAOProxy = (UserDAO)Proxy.newProxyInstance(userDAO.getClass().getClassLoader(), userDAO.getClass().getInterfaces(), li);
(1), 产生的代理对象的 classLoader 和 被代理对象的 classLoader 要一样，因为代理对象中有一个 被代理对象，所以需要互相访问。
(2), userDAO.getClass().getInterfaces() 代理类(对象) 要实现这个接口。
(3), 第三个参数，代理用哪一个 Handler 进行处理。
(4), 因为代理类实现了 UserDAO 接口，抽象主题，所以进行强制转换。(UserDAO)
System.out.println(userDAOProxy.getClass());
userDAOProxy.delete();
userDAOProxy.save(new User());
写程序推荐，面向接口编程。
15, <aop:aspectj-autoproxy />
把逻辑织入到原来那个方法里面去。
@Aspect 说明这是一个切面类
@Component 初始化这个类
public class LogInterceptor {
@Pointcut("execution(public * com.bjsxt.service..*.add(..))") 指定这个切面点
public void myMethod(){};
@Before("myMethod()") 加在前面
public void before() {
System.out.println("method before");
}
@Around("myMethod()") 前后都加
public void aroundMethod(ProceedingJoinPoint pjp) throws Throwable {
System.out.println("method around start");
pjp.proceed();
System.out.println("method around end");
用面向对象的思维考虑问题 ： 第一步【先考虑实体类】
1, 设计东西 ：需要先考虑实体类。
JUDE 一个 类似 UML 的工具。
2, 设计 ：图
UserDAO ： 负责和不同的数据库打交道。等价于它直接屏蔽了数据库。(是interface)
UserService : 用户管理服务层。 其中有 private UserDAO userDAO; 成员变量
对外公开的是业务逻辑，以后比如认证，权限...。
UserDAOImpl implements UserDAO
UserDAOImpl 可以分为 MysqlImpl, OracleImpl, ... 面向抽象编程(好处灵活)
装修房子用壁纸 ： 用符合国家生产规格的壁纸。 (尚学堂， 夏学堂生产的)
马士兵 ：10 年买起房子.
3, 各种 DAO, DAO 太多， TeacherDAO, ..., 将其写到配置文件中去。
4, Spring , xml配置文件 项目驱动是最快的学习方式。
(1), jdom学习 ：读取 xml 文件. google 搜索 例子 ：class Sample1.
dom4j 比 jdom 要强大一些。
以前马老师用的 JUnit, 这块你不要害怕，藐视它就可以，有它的视频。
5, spring 的核心，在于自动装配。
可以在配置文件中，将很多类的关系设计好。
beans.xml
<beans>
<bean id="u" class="com.bjsxt.dao.impl.UserDAOImpl"/>
<bean id="userService" class="com.bjsxt.service.UserService">
<property name="userDAO" bean="u"/>
<!-- 代表 userService 中有一个 setUserDAO 的方法，也就间接代表 其中有一个 userDAO 成员变量，其值初始化为 id 为 u 的 class。-->
</bean>
</beans>
一个类 UserService 里面 一个属性，可以给你指定好。在它生成的时候，就可以指定。
就看你配置文件怎么写。
6, 什么是 IOC (DI), 有什么好处？
(1), 把自己 new 的东西改为容器提供
(a), 初始化具体值
(b), 装配
(2), 好处, 灵活配置
7, Spring 的两大核心 ： (1) IOC (2) AOP
8, Spring 介绍 。 读 Spring API
问 ：spring3.1 这个 spring.jar 怎么不在 dist 文件夹里,是不是还要额外下载jar包?
答 ：spring3.0以上已经没有提供完整的spring包了，按功能模块被分解成了，实际开发时，选择你需要的包即可，core，beans，context，
在使用web开发中一般都需要被加入，如果你实际应用使用了aop等，这些包也要被加入。
9, // dependency injection - 依赖注入 示例程序中, UserService, DAO 都依赖于 容器的 注入
/* inversion of control 什么是控制反转？
(1), Service 成员 userDAO 控制在容器手里了，不用自己new实现。反转到容器那里去了！
(2), 原来编程控制的是实现，现在是接口,是抽象, 反转到抽象
(3), 你控制的是接口，而不是整个实现了！原来控制在自己手里，现在控制在别人的容器手里了。 “控制反转”
*/
@(1), 指定 XML, catalog 书写规范与提示 Spring_09 自动提示 马士兵.avi
注入类型
Spring_0300_IOC_Injection_Type
setter（重要）
构造方法（可以忘记）
接口注入（可以忘记）
@(2), 以上讲解的都是 setter 注入
11, annotation
@(1), 普通 java 文件 中 @overvide 编译期间
Annotation-based container configuration
<?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-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">
<context:annotation-config/>
</beans>
---------------------------------------------------------------------------------------
(The implicitly registered post-processors include
AutowiredAnnotationBeanPostProcessor, CommonAnnotationBeanPostProcessor,
PersistenceAnnotationBeanPostProcessor, RequiredAnnotationBeanPostProcessor.)
----------------------------------------------------------------------------------------
http://www.springframework.org/schema/beans/spring-beans-3.1.xsd 这个文件相当于当前 xml 文件的命名空间
xmlns = xml namespace xmlns:context="http://www.springframework.org/schema/context" 命名空间
代表这个xml文件，以context开头的对应的东西到哪里找。
对应的能够写的内容context="http://www.springframework.org/schema/context" 到哪里去找
@2, xsd 文件 是元数据, 一般称之为 xml 的语法。
12, JSR-250
JCP (google网址) 指定 java 的新标准
annotation 开发效率高
13, AOP
@1, 慎用继承 (因为继承直接就写死了！)
经常组合代替了继承，组合灵活性更高！
@2, Spring 解决了单例的问题
动态代理 jdk 如果想产生动态代理，那么这个类就需要实现一个接口，没有implements接口的类，JDK是给它产生不了动态代理的。
jdk proxy invocationhander
14,
UserDAO userDAO = new UserDAOImpl();
LogInterceptor li = new LogInterceptor();
li.setTarget(userDAO);
UserDAO userDAOProxy = (UserDAO)Proxy.newProxyInstance(userDAO.getClass().getClassLoader(), userDAO.getClass().getInterfaces(), li);
(1), 产生的代理对象的 classLoader 和 被代理对象的 classLoader 要一样，因为代理对象中有一个 被代理对象，所以需要互相访问。
(2), userDAO.getClass().getInterfaces() 代理类(对象) 要实现这个接口。
(3), 第三个参数，代理用哪一个 Handler 进行处理。
(4), 因为代理类实现了 UserDAO 接口，抽象主题，所以进行强制转换。(UserDAO)
System.out.println(userDAOProxy.getClass());
userDAOProxy.delete();
userDAOProxy.save(new User());
写程序推荐，面向接口编程。
15, <aop:aspectj-autoproxy />
把逻辑织入到原来那个方法里面去。
@Aspect 说明这是一个切面类
@Component 初始化这个类
public class LogInterceptor {
@Pointcut("execution(public * com.bjsxt.service..*.add(..))") 指定这个切面点
public void myMethod(){};
@Before("myMethod()") 加在前面
public void before() {
System.out.println("method before");
}
@Around("myMethod()") 前后都加
public void aroundMethod(ProceedingJoinPoint pjp) throws Throwable {
System.out.println("method around start");
pjp.proceed();
System.out.println("method around end");
}
什么是AOP
1, 面向切面编程Aspect-Oriented-Programming
a), 是对面向对象的思维方式的有力补充
2, Spring_1400_AOP_Introduction
3, 好处：可以动态的添加和删除在切面上的逻辑而不影响原来的执行代码
a), Filter
b), Struts2的interceptor
4, 概念：
a), JoinPoint 释意: 切面与原方法交接点 即 切入点
b), PointCut 释意: 切入点集合
c), Aspect（切面）释意:可理解为代理类前说明 【是切面】
d), Advice 释意:可理解为代理方法前说明 例如@Before [切入到那个点上的逻辑]
e), Target 释意:被代理对象 被织入对象
f), Weave 释意:织入
** 写程序的业务逻辑不要依赖某种先后顺序。
一个类如果没有实现接口，那么我们就用抛出二进制码的形式实现代理，CGLIB。实现接口了的，就用JDK proxy实现代理。
Annotation 实现 AOP 不是很重要的内容，留下印象。
Spring AOP配置与应用
1, 两种方式：
a), 使用Annotation
b), 使用xml
2, Annotation
a), 加上对应的xsd文件spring-aop.xsd
b), beans.xml <aop:aspectj-autoproxy />
c), 此时就可以解析对应的Annotation了
d), 建立我们的拦截类
e), 用@Aspect注解这个类
f), 建立处理方法
g), 用@Before来注解方法
h), 写明白切入点（execution …….）
i), 让spring对我们的拦截器类进行管理@Component
IOC 和 AOP 是 Spring 的两大核心概念
声明式的事务管理 ， dataSource 是提供标准化连接的方式。
在 Spring 中指定 dataSource, dataSource就是标准化取得连接的方式。
