从Spring入门到SpringIOC的应用

1.Spring是什么？

Spring是一个开源的轻量级的Java开发框架。

2.Spring有什么作用？
简化应用程序的开发。

3.简化应用程序开发体现在哪些方面？

①IOC容器
Java思想是面向对象的开发，一个应用程序是由一组对象通过相互协作开发出的业务逻辑组成，那么如何管理这些对象，使他们高效地协作呢？抽象工厂、工厂方法设计模式”可以帮我们创建对象，“生成器模式”帮我们处理对象间的依赖关系，不也能完成这些功能吗？可是这些又需要我们创建另一些工厂类、生成器类，我们又要而外管理这些类，增加了我们的负担。所以用另外的方式，如果对象需要的时候，就自动地生成对象，不用再去创建。举个例子：原来我们饿了，就出去吃饭，但是现在有了外卖之后，就可以订餐了，我们可以把我们的需求告诉美团，让他们给我们送饭。这里主导关系发生了变化，原来是我们自己，但是现在是美团。

Spring提出了一种思想：就是由spring来负责控制对象的生命周期和对象间的关系。所有的类都会在spring容器中登记，告诉spring你是个什么东西，你需要什么东西，然后spring会在系统运行到适当的时候，把你要的东西主动给你，同时也把你交给其他需要你的东西。所有的类的创建、销毁都由 spring来控制，也就是说控制对象生存周期的不再是引用它的对象，而是spring。对于某个具体的对象而言，以前是它控制其他对象，现在是所有对象都被spring控制，所以这叫控制反转（IOC）。
② AOP

比如进行一个计算器的编写，需要实现加、减、乘、除四种简单的运算，编写四种不同的方法。还有另外的两个需求是在每种运算之前和运算之后需要打印日志进行记录，需要进行数字合规的校验。我们就得考虑如何能简单地实现呢？就是得把日志记录和数据校验等可重用的功能模块分离出来，然后在程序的执行的合适的地方动态地植入这些代码并执行。这样就简化了代码的书写，业务逻辑代码中没有参和通用逻辑的代码，业务模块更简洁，只包含核心业务代码。实现了业务逻辑和通用逻辑的代码分离，便于维护和升级，降低了业务逻辑和通用逻辑的耦合。

有人会想到把这些通用的功能整合到一个方法中，去调用，这样也是避免不了重复调用，并且在业务逻辑中添加额外的代码。Spring通过配置的方式，而且不需要在业务逻辑代码中添加任何额外代码，就可以很好地实现上述功能。以上这种方式就是spring中实现的AOP：意思是面向切面编程，提供从另一个角度来考虑程序结构以完善面向对象编程（相对于OOP），即可以通过在编译期间、装载期间或运行期间实现在不修改源代码的情况下给程序动态添加功能的一种技术。通俗点说就是把可重用的功能提取出来，然后将这些通用功能在合适的时候织入到应用程序中；比如安全，日记记录，这些都是通用的功能，我们可以把它们提取出来，然后在程序执行的合适地方织入这些代码并执行它们，从而完成需要的功能并复用了这些功能。

③声明式事务

通过编程的方式对事务进行管理，特别麻烦。在Spring中，我们可以从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活地进行事务的管理，提高开发效率和质量。

④粘合剂
Spring是一个超级粘合平台，除了自己提供功能外，还提供粘合其他技术和框架的能力，从而使我们可以更自由的选择到底使用什么技术进行开发。

以上部分转载于https://blog.csdn.net/qq_38676810/article/details/80490682

一、Spring值的注入
1.Setter注入(最常用)
要求：必须其字段有对应的set方法
例如:
代码

public class Girl {

    private String name;

    private int years;

    private String size;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getYears() {
        return years;
    }

    public void setYears(int years) {
        this.years = years;
    }

    public String getSize() {
        return size;
    }

    public void setSize(String size) {
        this.size = size;
    }
}

xml文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://www.springframework.org/schema/beans 		 http://www.springframework.org/schema/beans/spring-beans.xsd">

<!--将对象的创建交给spring容器，在这个配置文件里面去声明我要什么对象。
   class:写java类的全限定类名，它是通过全类名然后使用反射技术创建的。
 id: ID就是给对象在整个应用程序上下文当中取个名字-->

<bean class="com.Spring.Pojo.Girl" id="girl">
	<!--name指定要输入的属性名称，value给其赋值-->
    <property name="name" value="马云"></property>
</bean>
</beans>

**Test代码**
	
@Test
    public void test1(){
        //获取上下文对象，spring里面声明的对象需要通过上下文获取
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        //通过对象获取girl,getBean是获取xml文件中的bean
        Girl girl =(Girl) ctx.getBean("girl2");
        System.out.println(girl);
    }

2.构造注入
注意：构造注入有多种方式，这里演示了一种最常见的

代码

		public class Car {

        private String name;

        private double price;

        private int year;

//这里重写了一下ToString方法，目的是更好的打印数据
        @Override
        public String toString() {
            return "Car{" +
                    "name='" + name + '\'' +
                    ", price=" + price +
                    ", year=" + year +
                    '}';
        }

        public Car(String name, double price, int year) {
            this.name = name;
            this.price = price;
            this.year = year;
        }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }
}

xml文件

		<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://www.springframework.org/schema/beans 		 http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="car" class="com.Spring.Pojo.Car">

	<!--name和value同上-->
    <constructor-arg name="name" value="马飞"></constructor-arg>
    <constructor-arg name="price" value="666.66"></constructor-arg>
    <constructor-arg name="year" value="20"></constructor-arg>
</bean>
</beans>

**Test代码**


@Test
    public void test4(){

        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        Car car = ctx.getBean("car",Car.class);

        System.out.println(car);
    }

这里只简单的复述了基本的注入方式，在实际应用中还会将数据注入集合
如数组、List、Set、Map

二、bean元素的探讨

abstract : 无法被实例化
destory-method: 销毁时一定执行的方法
init-method: 最先执行（即在程序运行之前就立即执行，执行此操作后在执行下一步）
lazy-init: 延迟初始化,使用到此bean在初始化
相对于init-method的优点：程序启动快，内存消耗小
缺点：使用bean时会慢一点
partent:指定父bean,继承父bean的信息
name:别名
depends-on:使依赖于莫个bean，在使用的时候先启动依赖的bean
autowire:根据所选属性自动注入
byType：根据类型进行注入它的属性
primary：明确主要的注入
byName：按照bean对应的pojo里面的名字进行匹配注入
constructor：优先按照类型去匹配，如果匹配到一个，那么直接使用，如果匹配到多个，则按照名字注入

贴上部分代码：
xml文件

		<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

<bean id="User" class="com.Spring.Pojo.boy" autowire="constructor">
    <property name="name" value="nb"/>
    <property name="height" value="180"/>
    <property name="year" value="19"/>
</bean>

<bean class="com.Spring.Pojo.Cat" id="cat">
    <property name="name" value="加菲猫"></property>
</bean>
</beans>

**pojo代码**


public class Cat {

    private String name;

    private double year;

    public String getName() {
        return name;
    }

    public double getYear() {
        return year;
    }

    public void setYear(double year) {
        this.year = year;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                ", year=" + year +
                '}';
    }
}

---

public class boy {

    private String name;

    private int year;

    private Cat cat;

    private double height;

    @Override
    public String toString() {
        return "boy{" +
                "name='" + name + '\'' +
                ", year=" + year +
                ", cat=" + cat +
                ", height=" + height +
                '}';
    }

    public Cat getCat() {
        return cat;
    }

    public void setCat(Cat cat) {
        this.cat = cat;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }
}

Test代码

   @Test
    public void autowire(){

        ApplicationContext ctx = new ClassPathXmlApplicationContext("Autowire.xml");

        boy boy1 = ctx.getBean("User",boy.class);

        System.out.println(boy1);

        ((ClassPathXmlApplicationContext) ctx).close();
    }