Spring第二天：AOP、IOC、DI概念初识

Spring的核心

Spring核心概念有控制反转(Ioc)、向切面编程(AOP)、和依赖注入(DI)这三个！这三个核心技术是学习spring的基础，其它大多数都是基于它们集成。我们分别来介绍.

spring的官网地址：https://spring.io

1.控制反转(Ioc)：概念（控制权发生反转）

2.IOC的作用

削减计算机程序之间的耦合（解除我们代码中的依赖关系），只能削减，并不能完全消除！
spring ioc，它并不能实现我们数据库的增删改查，也不能实现我们表现层的数据封装，它也无法接受请求，它能干的事情，就是很简单，它就是为了解决程序之间的耦合。

3.spring中IOC解释

在我们以前写Java程序的时候，创建一个类的时候，由这个类自己去new一个对象，不过在spring中可不是这样的，比如我们的目标类：UserService接口和实现类，之前获得UserService实例之前，直接new一个对象即可，而现在，将由spring去创建对象的实例，我们就把这个过程叫做控制反转IOC（Inverse Of Control),创建实例的权限交给了spring，如果我们以后需要对象实例怎么办？答案是简而易知的，直接从spring中拿来即用即可！

• IOC实例
  1.新建一个spring项目
  
  2.新建一个配置文件
  
  3.在src下新建com.main包，并新建一个类

ackage com.main;
import com.test.IntroduceDemo;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class testMain {
    
    
    public static void main(String[] args) {
    
    
        //创建Spring上下文（加载bean.xml）
        ApplicationContext acx= new ClassPathXmlApplicationContext("beans.xml");
        //获取testMain中类的实例，在beans.xml取
        IntroduceDemo id=acx.getBean("IntroduceDemo",IntroduceDemo.class);
        //调用显示名字、年龄的方法
        id.show();
    }
}

4.在src下建一个包com.test包，并新建一个类

package com.test;



public class IntroduceDemo {
    
    
    //姓名
    private String name;
    //年龄
    private  int  age;

    public int getAge() {
    
    
        return age;
    }

    public void setAge(int age) {
    
    
        this.age = age;
    }

    public String getName() {
    
    
        return name;
    }

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

    /**
     * 自我介绍
     */
    public void show(){
    
    
        System.out.println("您好，我叫"+this.name+"今年"+this.age+"岁！");
    }

}

5.在src同级目录的beans.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="IntroduceDemo" class="com.test.IntroduceDemo">
        <property name="name" value="码里安乐窝"/>
        <property name="age" value="23"/>
    </bean>


</beans>

项目结构：

结果：由spring创建对象成功

依赖注入(DI)Dependency Injection

依赖注入是spring容器为其对象构建依赖关系的一种方式，我们给spring一个需要创建对象的列表，比如说创建A对象和跟其依赖关系的对象，先在列表中查找，有没有找到这些依赖的对象，假设A对象依赖于很多对象，并不知道其他对象是否存在或者其他对象在哪里以及被他们是如何创建，而spring容器会将A依赖的对象主动创建好并将其注入到A中,比如A依赖C，将C自动注入到A的对象中！
1.首先来了解什么是依赖：一个对象需要使用另一个对象，我们就说他们存在依赖。

class B {
    
    
           private A a;   //B类依赖A类
        }

比如有两个类：A和B，都有show方法

public class A{
    
    
    public void show(){
    
    }
}
public class B{
    
    
    public void show(){
    
    }
}

假设A的show（）方法需要调用B中的show（）方法完成一些功能，则

// An highlighted block
public class A{
    
    
   private B b;
   public class A(B b){
    
    
   this.b=b;

  }
    public void show(){
    
    
    this.b.show();
    }
}

在实际中，如果A中的show需要调用一大堆类似show的方法呢？一个一个对象的创建，代码量比较大，而且修改是繁琐，这时候在spring为我们提供的对象清单中查找，如果A需要哪个对象，则去查找，直接返回对象就可以，那将很舒服，也有利于扩展！

DI案例演示
目标类
创建BookService接口和实现类

// An highlighted block
var foo = 'bar';

创建BookDao接口和实现类
将dao和service配置 xml文件
测试
在src下新建三个包，com.service、com.dao、com.main

com.service：一个接口一个实现类

package com.service;

public interface BookService {
    
    
    public abstract void addBook();
}
package com.service;

import com.dao.BookDao;

public class BookServiceImpl implements BookService{
    
    
    private BookDao bookDao;
    public void setBookDao(BookDao bookDao) {
    
    
        this.bookDao = bookDao;
    }

    @Override
    public void addBook(){
    
    
        this.bookDao.addBook();
    }
}

com.dao：一个接口一个实现类

package com.dao;

public interface BookDao {
    
    
    public void addBook();

}
package com.dao;

public class BookDaoImpl implements BookDao{
    
    
    @Override
    public void addBook(){
    
    
        System.out.println("di addBook()");
    }
}

main函数测试

package com.mainjava;

import com.service.BookService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainTest {
    
    
    public static void main(String[] args) {
    
    
        String xmlPath = "springContext.xml";
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
        BookService bookService = (BookService) applicationContext.getBean("bookServiceId");

        bookService.addBook();
    }
}

springContext.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="bookServiceId" class="com.service.BookServiceImpl">
        <property name="bookDao" ref="bookDaoId"></property>
    </bean>

    <!-- 创建dao实例 -->
    <bean id="bookDaoId" class="com.dao.BookDaoImpl"></bean>
</beans>

结果：

面向切面编程(AOP)

先来了解Spring中的AOP功能的作用再来仔细分析AOP
在spring 中，AOP能方便进行切面的编程。许多不容易用传统OOP实现的功能可以通过AOP轻松应对。
Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能,因为篇幅原因，下篇再继续写AOP了！