Spring基础学习，附例子代码讲解
什么是Spring、IOC、AOP、DI？
Spring是一个基于IOC和AOP的结构J2EE系统的框架。
IOC（Inversion Of Control）控制反转（Spring的基础，创造对象由以前的程序员new构造方法来调用，变成交由Spring创建对象）
AOP（Aspect Oriented Programming）面向切面编程 （在面向切面编程中，功能分为核心业务功能（登陆、增删改查）和周边功能（即切面，例如性能统计、日志、事务管理），两者可以独立开发，最后在通过配置文件进行交织在一起）
DI（Dependency Injection）依赖注入（简单来说就是拿到了对象的属性，已经注入好相关值了，直接使用即可）
#第一部分：IOC、DI
1、首先创建一个pojo包，里面有个Product.java
pack com.test.pojo
import ......
public class Product {
private String name;
public void setName(String name) {
this.name=name;
}
public String getName() {
return name;
}
}
2、在applicationContext.xml中配置Product的属性
<?xml>
<beans ......>
<bean name="p" class="com.test.pojo.Product">
<property name="name" value="天地一号">
</bean>
</beans>
3、测试类测试是否运行成功
package com.test.test;
import com.test.pojo.Product;
public class TestSpring{
ApplicationContext context = new ClassPathXmlApplicationContext(new String [] {"applicationContext.xml"});
Product p = (Product) context.getBean("p");
System.out.println(p.getName()); // 输出： 天地一号
}
#第二部分：注入对象
1、在刚刚的基础基础之上，创建一个Category.java
pack com.test.pojo
import ......
public class Category{
private String name;
public void setName(String name) {
this.name=name;
}
public String getName() {
return name;
}
}
2、在applicationContext.xml中追加配置Category这个bean对象
<?xml>
<beans ......>
<bean name="p" class="com.test.pojo.Product">
<property name="name" value="天地一号" >
<property name="category" ref="c"> <!--DI体现：注入Category这个bean对象-->
</bean>
<bean name="c" class="com.test.pojo.Category">
<property name="name" value="饮料类别">
</bean>
</beans>
3、测试类测试是否运行成功
package com.test.test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
// 注意，这里虽然用到了Category这个对象，但是不用导入包，因为在xml配置文件里面，早已经把Category注入到了Product这个bean对象当中！！！
import com.how2java.pojo.Product;
public class TestSpring {
public static void main(String[] args) {
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()); // 输出：饮料类别
}
}
#第三部分：注解方式
为什么使用注解？
这是因为注解，能够减轻applicationContext.xml这个spring配置文件的代码负担，所以说，注解最大的好处是简化了XML的配置。要不然你写代码的时候，这边写java还要切换到xml那边再看类的配置是怎样的，这样开发效率太低了。
3.1 @Autowired的注解方式
1、首先，在xml文件中注释掉之前注入到Product类的Category类，然后在前面添加一行以下代码
<context:annotation-config/> // 表示告诉Spring要用注解的方式进行配置
applicationContext.xml文件修改具体如下：
<?xml>
<beans....>
<context:annotation-config/> // 加上这一行，表示告诉spring要用注解的方式进行配置
<bean name="c" class="com.test.pojo.Category">
<property name="name" value="category 1" />
</bean>
<bean name="p" class="com.test.pojo.Product">
<property name="name" value="product1" />
<!-- <property name="category" ref="c" /> --> //注释掉这一行
</bean>
</beans>
2、直接在Product中，把Category放进去，加上get/set方法，然后@Autowired可以放在两处地方，具体如下修改Proudct类
package com.test.pojo;
import org.springframework.beans.factory.annotation.Autowired; // 别忘了引入注解的包
public class Product {
private int id;
private String name;
@Autowired // 注解位置一 很强的地方在于，不用import Category 这个类！！！！
private Category category;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Category getCategory() {
return category;
}
// @Autowired //注解位置2
public void setCategory(Category category) {
this.category = category;
}
}
3.2 @Resource的注解方式
说明：@Resource是J2ee的规范，而@Autowired
@Resources是J2ee的规范，而@Autowired是Spring 的规范，通过注解的形式把原本写在xml中的依赖替代，在xml中添加<context:annotation-config/>以通知Spring解析注解，简化操作；注解本质是一种标记，只是告知作用
package com.test.pojo;
import javax.annotation.Resource; // 别忘了引入注解的包
public class Product {
private int id;
private String name;
@Resource(name="c")
private Category category;
....
....
}
3.3 对bean的注解 @Component
3.1和3.2的注解方式是对注入对象行为的注解，那么其实还有一种注解，可以直接对bean进行注解，意思是把Product、Category这些bean直接移出applicationContext.xml配置文件。
1、修改之前的applicationContext.xml，把之前写的东西全部删除掉，只需要新增下面这句：
<?xml>
<beans ...>
<context:component-scan base-package="com.test.pojo"/> // 告诉Spring，bean都放在com.test.pojo这个包下面了
2、因为applicationContext中已经没有配置bean的属性了，所以在Product、Category类中，需要自己自定义私有属性，并且在类的头部添加注解 @Component，表明此类是bean如下：
Product.java
package com.test.pojo;
import javax.annotation.Resource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component("p") // 对bean的注解，表面此类是bean
public class Product {
private String name="天地一号";
@Autowired // 注意注入还是少不了的！！
private Category category;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Category getCategory() {
return category;
}
public void setCategory(Category category) {
this.category = category;
}
}
Category.java
package com.test.pojo;
import org.springframework.stereotype.Component;
@Component("c") // 对bean的注解，表面此类是bean
public class Category {
private String name="饮料类别";
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
3.4 对上面注解进行测试（同一个main函数，会发现运行结果是一样的）
package com.test.test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.how2java.pojo.Product;
public class TestSpring {
public static void main(String[] args) {
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()); // 输入：饮料分类
}
}
#第四部分：注解方式写Java单元测试（可忽略，有空可以了解）
为什么要用到测试类？为什么要单元测试？
单元测试是编写测试代码，应该准确、快速保证程序基本模块的正确性
简单来说，就是类里面的方法就是一个单元，看看每一个方法是否正确，这个正确性的标准很广，它分很多方面，例如一个两数相加的方法add，给他一个用例，add（1，1），然后给它一个正确的答案2，看看计算出来的结果是否等于预期结果2。
这是一方面，另一方面，例如
限时测试
有时候，一些方法里面的逻辑非常复杂，循环嵌套比较深，很可能出现死循环，那你要怎么预防呢？限时测试可以帮到你。我们给测试函数设定一个执行时间，超过这个时间，就会被系统强行终止，然后系统会告诉你终止的原因是因为超时，这样就可发现这些Bug了。而且用JUnit很好实现，只需要给@Test添加一个timeout参数就行。
@Test(timeout = 1000)
异常测试
java由抛出异常机制。如果有一个函数需要抛出自定的异常，但是它没抛出来，这就是一个BUG了。例如10除以0，理应抛出ArithmeticException.class异常，所以我们需要设置一个测试类来测试它到底有没有抛出异常，并且是不是我们想要的异常，JUnit也帮我们实现了，
@Test(expected = ArithmeticException.class)
参数化测试
这个对测试人员非常有用，例如一个函数，它的参数有许多的特殊值，即有很多区域，例如“计算一个平方”这个函数，暂且分为三个区域：正数、0、负数，所以写测试的时候，需要在测试类里面至少写三个测试方法，但是JUnit的参数化测试，就简化了，只需要写一个方法就OK，原理是把参数数组塞进同一个方法体，让它自动执行就行。
@Parameters
public static Collection data() {
return Arrays.asList(new Object[][]{
{2, 4},
{0, 0},
{-3, 9},
});
}
测试类注解简单例子
package com.test.test;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import com.test.pojo.Category;
@RunWith(SpringJUnit4ClassRunner.class) // 表示这是一个Spring的测试类
@ContextConfiguration("classpath:applicationContext.xml") // 定位Spring的配置文件
public class AnnotationTest {
@Autowired // 给测试类装配Category对象
Category c;
@Test // 测试逻辑，打印c对象的名称
public void test() {
System.out.println(c.getName());
}
}
注：JUnit4是Java单元测试框架，已经在eclipse中默认安装，通过配置可以快捷地生成对应的测试类。
第四部分参考博客：https://www.cnblogs.com/happyzm/p/6482886.html
