[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");

}

什么是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就是标准化取得连接的方式。