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