Spring(2018-08-28)

一.IOC/DI

Spring是一个基于IOC和AOP的结构J2EE系统的框架IOC反转控制（Inversion of control）是Spring的基础，简单的说创建对象由以前的程序员自己new构造方法来调用，变成了交由spring创建对象（DI依赖注入Dependency Inject）,简单的说就是拿到对象的属性，已经被注入好相关值了，直接可以使用

必读：基于框架的程序要成功运行，对于JAR包的版本，配置文件的正确性有严格的要求

1.新建项目在e:\project\spring目录下新建spring项目 (java project类型)

2.下载包 lib.rar，并解压到 e:/project/spring/lib 目录下

3.导入包

4.pojo

5.applicationContext.xml

在src目录下新建applicationContext.xml文件Spring的核心配置文件，通过关键字c即可获取Category对象，该对象获取的时候，即被注入了字符串"category 1“到name属性中

6.TestSpring

ApplicationContext context = new ClassPathXmlApplicationContext( new String[] {"applicationContext.xml" });

Category c = (Category) context.getBean("c");

System.out.println(c.getName());

二.注入对象

1.Product.java

2.applicationContext.xml

在创建Product的时候注入Category对象，注意，这里使用ref来注入另一个对象

<bean name="c" class="com.how2java.pojo.Category">

<property name="name" value="category 1" />

<bean>

<bean name="p" class="com.how2java.pojo.Product">

<property name="name" value="product1" />

<property name="category" ref="c" />

</bean>

3.TestSpring

通过Spring拿到的Product对象已经被注入了Category对象了

ApplicationContext context = new ClassPathXmlApplicationContext(new String[] { "applicationContext.xml" });

Product p = (Product) context.getBean("p");System.out.println(p.getName());

System.out.println(p.getCategory().getName());

三.注入方式IOC/DI

1.修改applicationContext.xml

<context:annotation-config/>

表示告诉Spring要用注解的方式进行配置、

2.@Autowired

在Product.java的category属性前加上@Autowired注解

@Autowiredprivate

Category category;

3.运行测试

4.@Autowired的位置

@Autowired

public void setCategory(Category category)

5.@Resource

@Resource(name="c")

private Category category;

6.对Bean的注解

上述例子是对注入对象行为的注解，那么bean对象本身，比Category,Product可移出applicationContext.xml配置文件修改applicationContext.xml，什么都去掉，

只新增：

<context:component-scan base-package="com.how2java.pojo"/>

7.@Component

为Product类加上@Component注解，即表明此类是bean

@Component("p")

public class Product {

为Category 类加上@Component注解，即表明此类是bean

@Component("c")

public class Category {

另外，因为配置从applicationContext.xml中移出来了，所以属性初始化放在属性声明上进行了。private String name="product 1";

8.运行测试

private String name="category 1";

四.AOP

AOP是面向切面编程（Aspect Oriented Program）

首先，在面向切面的思想中，把功能分为核心业务功能和周边功能

所谓核心业务，比如登录，增加数据，删除数据

所谓周边功能，比如性能统计，日志，事物管理等

周边功能在Spring切面编程AOP思想里，被定义为AOP在面向切面AOP的思想里面，核心业务功能和切面功能分别独立进行开发，然后把切面功能和核心业务功能“编织”在一起，这就叫AOP

1.jar包

为了支持AOP，需要用到一些额外的JAR包

2.思路图

（1）功能分成两大类，辅助功能和核心业务

（2）辅助功能和核心业务功，能彼此独立进行开发

（3）比如登录功能，即便没有性能统计和日志输出，也能正常运行

（4）如果有需要，就把“日志输出”功能和“登录”功能编织在一起，这样登录的时候，就可以看到日志输出了

（5）辅助功能，又叫切面，这种能够选择性，低耦合的把切面和核心业务功能结合在一起的编程思想，就叫切面编程

3.准备业务类 ProductService

4.TestSpring 在引入切面之前，调用该业务类

5.准备日志切面 LoggerAspect 该日志切面的功能是在调用核心功能之前和之后分别打印日志

Object object = joinPoint.proceed(); //就是将来与某个核心功能编织之后，用于执行核心功能的代码

6.applicationContext.xml

//声明业务对象

<bean name="s" class="com.how2java.service.ProductService">

</bean>

//声明日志切面

<bean id="loggerAspect" class="com.how2java.aspect.LoggerAspect"/>

//指定右边的核心业务功能

<aop:config>

<aop:pointcut id="loggerCutpoint" expression="execution(* com.how2java.service.ProductService.*(..)) "/>

//指定左边的辅助功能，然后通过aop:config把业务对象与辅助功能编织在一起。

<aop:aspect id="logAspect" ref="loggerAspect">

<aop:around pointcut-ref="loggerCutpoint" method="log"/>

</aop:aspect>

</aop:config>

execution(* com.how2java.service.ProductService.*(..)) 这表示对满足如下条件的方法调用，进行切面操作：* 返回任意类型

com.how2java.service.ProductService.* 包名以 com.how2java.service.ProductService 开头的类的任意方法(..) 参数是任意数量和类型

7.TestSpring

五.注解方式AOP

1.注解配置业务类

使用@Component("s") 注解ProductService 类

@Component("s")

public class ProductService {

public void doSomeService() { System.out.println("doSomeService"); }

}

2.注解配置切面

@Aspect 注解表示这是一个切面

@Component 表示这是一个bean,由Spring进行管理

@Around(value = "execution(* com.how2java.service.ProductService.*(..))") 表示对com.how2java.service.ProductService 这个类中的所有方法进行切面操作

@Aspect

@Component

public class LoggerAspect {

@Around(value = "execution(* com.how2java.service.ProductService.*(..))")

   public Object log(ProceedingJoinPoint joinPoint) throws Throwable {

   System.out.println("start log:" + joinPoint.getSignature().getName());

   Object object = joinPoint.proceed();

   System.out.println("end log:" + joinPoint.getSignature().getName()); return object; }

}

3.applicationContext.xml

<context:component-scan base-package="com.how2java.aspect"/>

<context:component-scan base-package="com.how2java.service"/>

<aop:aspectj-autoproxy/>

去掉原有信息，添加如下3行扫描包com.how2java.aspect和com.how2java.service，定位业务类和切面类

<aop:aspectj-autoproxy/>找到被注解了的切面类，进行切面配置

4. 运行测试

六.注解方式测试

1.jar

注解方式用到了junit,所以需要在右上角下载:junit-4.12.jar和hamcrest-all-1.3.jar

2.TestSpring

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration("classpath:applicationContext.xml")

public class TestSpring {

@Autowired

Category c;

@Test

public void test(){

System.out.println(c.getName());

}

}

修改TestSpring, 并运行

1. @RunWith(SpringJUnit4ClassRunner.class)

表示这是一个Spring的测试类

2. @ContextConfiguration("classpath:applicationContext.xml")

定位Spring的配置文件

3. @Autowired

给这个测试类装配Category对象

4. @Test

测试逻辑，打印c对象的名称

Spring