学习Spring的第4天

@Resource
@Autowired
区别：
1、@Autowired是Spring自己的注解，最强大
2、@Resource 是J2EE的。java的标准

因为@Resource是标准，所以它的扩展性很强。即使你的容器用的不是Spring。切换为另一个框架，@Resource照样适用。

@Autowired是Spring自己的注解，所以@Autowired离开了Spring就没办法使用了。

注意地方：
1、你想要使用@Autowired自动装配，那你就先要把一些组件带上那四大注解中的某一个才行。（先要成为人家的会员）


注意二：


原因：是因为：

这个类TOTest上面没有加上四大注解中的一个。
它都没有成为Spring的会员。
我们说：框架会自动去扫描基础包下面的，标了四大注解的那些类。

还有一种死循环的情况：

为什么会死循环呢？
执行步骤：
1、你run test()方法。就会去new 一个IOTest对象
2、只要去new IOTest()，就会执行：

    ApplicationContext ioc = new ClassPathXmlApplicationContext("ioc4.xml");

这句话。
一旦执行这句话。就会扫描到IOTest这个类。因为，这个类的上面是@Component
3、扫描了之后，就会去new IOTest()。。。
这时候，就进入了循环。

如何使用Spring的单元测试呢？

1、导包：
spring-test-4.0.0.RELEASE
为什么我们要使用Spring的单元测试呢？不是有junit单元测试吗？

使用Junit的单元测试，发现bookService不能赋值。因为IOTest类上没有加上四大注解的一个。
如果给IOTest类加上注解，又会出现死循环执行的情况。
所以，这种情况为了给bookService成功赋值上去，只能使用Spring的单元测试了，Junit的单元测试是不行的。

解释：
其中@ContextConfiguration(locations = "classpath:ioc4.xml")使用这个来指定Spring的配置文件的位置。
@RunWith(SpringJUnit4ClassRunner.class)指定用哪种驱动进行单元测试，默认就是junit，加上这个SpringJUnit4ClassRunner.class，就把Junit测试换成了Spring的单元测试。之前的@Test都是由Junit来执行。@ContextConfiguration(locations = "classpath:ioc4.xml")
@RunWith(SpringJUnit4ClassRunner.class)
public class IOCTest {ApplicationContext ioc = null;@Autowiredprivate BookService bookService;@Testpublic void test(){System.out.println("bookService"+bookService);}
}

使用Spring的单元测试的好处，其实就是，我们不用ioc.getBean()来获取组件了，直接Autowired获取，Spring为我们自动装配。

测试泛型的依赖注入。（难但是重要）

为什么会引入泛型依赖注入呢？
首先：看一下原先的代码架构。
在DAO层，有三个，分别是BaseDao，BookDao,UserDao
BaseDao:

package com.rtl.dao;//这个类里面定义了一些基本的增删改查的方法。
public abstract class BaseDao<T> {public abstract void save();
}

2、BookDao：

package com.rtl.dao;import com.rtl.bean.Book;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Repository;@Repository
public class BookDao extends BaseDao<Book> {@Overridepublic void save() {System.out.println("BookDao   保存图书 .........");}
}

3、UserDao：

package com.rtl.dao;import com.rtl.bean.User;
import org.springframework.stereotype.Repository;@Repository
public class UserDao extends BaseDao<User>{@Overridepublic void save() {System.out.println("UserDao  保存用户.....");}
}

在Service层里面有两个：BookService和UserService

BookService：

package com.rtl.service;import com.rtl.dao.BookDao;
import com.rtl.servlet.BookServlet;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;import javax.annotation.Resource;@Service
public class BookService {@Resourceprivate BookDao bookDao;public void save(){bookDao.save();}}

UserService：

package com.rtl.service;import com.rtl.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;@Service
public class UserService {@Autowiredprivate UserDao userDao;public void save(){userDao.save();}
}

测试类：

测试结果：

改进之后的代码：
添加了一个BaseService
然后，UserService和BookService都继承了BaseService。

BaseService：这是一个很关键的类。

注意：这个类上面并没有那四大注解。

public class BaseService<T>{@Autowiredprivate BaseDao<T> baseDao;public void save(){baseDao.save();}
}

之前的BaseDao也是没有注解的。

UserService:

@Service
public class UserService extends BaseService<User>{
}

BookService:

@Service
public class BookService extends BaseService<Book>{
}

测试：

问：在BaseService类里面，它的类上面并没有添加注解，为什么baseDaoa对象不是空的呢？

答：
因为在BookService这个类继承了BaseService。
而BookService加了@Service注解。

继承了之后，相当于这块代码就在BookService里面了。


所以，baseDao就不是null。

奇怪的事情：
这个baseDao不是null，但是你写代码的时候，idea会说你是null。但是你又可以运行。很诡异。！！！

泛型依赖注入的原理：

结论就是：
之前，我们在进行注入匹配的时候：
1、按照数据类型去匹配
2、相同的就按照属性名作为id去匹配。
现在又多了一种：就是看泛型。

比如：
按照数据类型是BaseDao去匹配。那么有两个：
一个是BaseDao
另一个是BaseDao
这个时候的参考依据就是看你的泛型类型是什么来决定。

IOC总结：

IOC是一个容器，它帮我们管理组件。
DI：依赖注入。哪些组件需要另外一些组件，只需要一个注解@Autowired，进行自动赋值。
要想使用Spring,你先成为Spring的会员。（也就是你这个组件要先加入到容器里面去）

1、容器在启动的时候，都会自动创建所有的单实例的对象
2、在Autowired自动装配的时候，它是从容器里面去找那些符合要求的bean
3、使用代码：

ioc.getBean();

的形式获取bean的时候，其实也是从容器里面去找这个bean
4、容器里面包含了所有的bean

调试Spring的源码。查看容器的本质到底是什么？
本质就是Map。
这个Map对象，保存了所有创建好的bean，并给外界提供获取的功能。
探索：
单实例的bean保存到哪个map里面？

AOP：

Aspect Oriented Programming
面向切面编程

OOP：
Object Oriented Programming
面向对象编程

面向切面编程，是基于OOP基础之上的编程思想。

面向切面编程的意思：

在程序运行期间，将某段代码，动态的切入到 指定方法 的 指定位置
进行运行
举例子：
1、建一个接口，里面有加减乘除的方法。

public interface Calculator {int add(int i, int j);int sub(int i, int j);int mul(int i, int j);int div(int i, int j);
}

2、实现类：

package com.rtl.impl;import com.rtl.inter.Calculator;public class MyMathCalculator implements Calculator {@Overridepublic int add(int i, int j) {int result = i + j ; return result;}@Overridepublic int sub(int i, int j) {int result = i - j ;return result;}@Overridepublic int mul(int i, int j) {int result = i * j ;return result;}@Overridepublic int div(int i, int j) {int result = i / j ;return result;}
}

3、写测试类（没有日志记录的）

public class AOPTest {@Testpublic void test(){Calculator calculator = new MyMathCalculator();int result = calculator.add(1, 2);System.out.println(result);}
}

改进：

开始加日志记录了：

第一种方式：每个方法内部加上日志打印。

之前的方法：

现在的方法：

每个方法里面都加了这个日志的打印。

发现，这种方式（每个方法内部加上日志打印。）添加日志是很不好的，维护起来非常的麻烦。

第2种方式：动态代理。

我们的加减乘除才是核心功能。
日志功能只是系统的辅助性的功能。
我们上一种方式，就是将核心功能和辅助功能耦合了。
我们希望：
核心功能不变，但是辅助功能是在核心功能运行期间，动态的加上。

回到这里例子就是：
执行加减乘除的时候，才会加上日志的功能。
怎么实现呢？

动态代理

思想：
我们的加减乘除的方法，不要自己new 对象（MyMathCalculator）然后用对象.的形式调用add()。

而是想办法使用代理对象去执行加减乘除。
这时候，代理对象会帮我们调用加减乘除。而且在代理对象调用加减乘除的前后帮我们做一些事情。

例如：
Caculator proxy = CaculatorProxy.getProxy(Caculator);
proxy.add(1,2);

那么问题来了：
如何制作CaculatorProxy呢？
这个CaculatorProxy是一个帮Caculator生成代理对象的类。
JDK里面支持动态代理
java.lang.reflect.Proxy

这个类里面有一个方法是：

 public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)