IOC

IoC

  • 接口及面向接口编程
  • 什么是IoC
  • Spring的Bean配置
  • Bean的初始化
  • Spring的常用注入方式

java接口声明了那些方法是对外公交的

面向接口编程

  • 在结构设计中，分清层次以及调用关系，每层只向上层提供一组功能接口，各层间仅依赖接口而非实现类
  • 接口实现的变动不影响各层间的调用
  • “面向接口编程”中的“接口”是用于隐藏具体实现和实现多态性的组件

什么是多态？（复习下java基础知识）

父类或接口指向子类对象。

多态的好处：提高了代码的扩展性，前期定义的代码可以使用后期的内容。

多态的弊端: 前期定义的内容不能调用后期子类的特有内容。

实现多态的前提：

  1. 必须有关系（继承或实现）
  2. 要有覆盖

多态成员的特点

成员变量：

编译时：参考引用变量所属类中是否有调用的成员变量，有，则编译通过，没有，编译失败。

运行时：参考引用变量所属类中是否有调用的成员变量，并运行该所属类中的成员变量。

一句话概括：（编译和运行都参考等号的左边）

成员函数：

编译时：参考引用变量所属类中是否有调用的函数，有，则编译通过，没有，编译失败。

运行时：参考的是对象所属的类中是否有调用的函数。

一句话概括：（编译看左边运行看右边）

静态函数：

编译时：参考引用变量所属类中是否有调用的静态函数，有，则编译通过，没有，编译失败。

运行时：参考引用变量所属类中是否有调用的静态函数。

一句话概括：（编译和运行都参考等号的左边）

其实调用静态函数（方法）常用的是直接类名调用即可。

Father

/**
* @author LJW
* @project testjava
* @package polymorphic
* @file    Father.java
* @time 2017-12-14 16:28:28
*/
public class Father {

static  String message="Father";
/**
 *  年龄
 */
int age;

/**
 * 姓名
 */
String name;

public Father(){
    this.age=40;
    this.name="小头爸爸";
}

public Father(int age,String name){
    this.age=age;
    this.name=name;
}

public void say(){
    System.out.println("Father: age:"+this.getAge()+",name:"+this.getName());
}

public static void sayTwo(){
    System.out.println("Two:Father: "+message);
}

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;
}
}

Son

/**
* @author LJW
* @project testjava
* @package polymorphic
* @file    Son.java
* @time 2017-12-14 16:44:44
*/
public class Son extends Father {

static String message="Son";

/**
 *  年龄
 */
int age;

/**
 * 姓名
 */
String name;

public Son(){
    this.age=24;
    this.name="大头儿子";
}

public Son(int age,String name){
    this.age=age;
    this.name=name;
}

public void say(){
    System.out.println("Son:  age:"+this.getAge()+",name: "+this.getName());
}

public static void sayTwo(){
    System.out.println("Two:Son: "+message);
}

@Override
public int getAge() {
    return age;
}

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

@Override
public String getName() {
    return name;
}

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

Test

/**
 * @author LJW
 * @project testjava
 * @package polymorphic
 * @file  Test.java
 * @time 2017-12-14 16:52:52
 */
public class Test {
public static void main(String[] args) {
    Father temp=new Son();

    System.out.println("age:"+temp.age+",name:"+temp.name);   //成员变量
    temp.say();                     //成员函数
    System.out.println(temp.message);//不建议这样写   类.静态变量
    temp.sayTwo();                  //不建议这样写   类.静态函数
}
}

结果：

接口

OneInterface

/**
 * @author LJW
 * @project testjava
 * @package polymorphic
 * @file  OneInterface.java
 * @time 2017-12-15 21:17:17
 */
public interface OneInterface {
    String name="OneInterface";
    public void say();
}

OneInterfaceImpl

/**
 * @author LJW
 * @project testjava
 * @package polymorphic
 * @file  OneInterfaceImpl.java
 * @time 2017-12-15 21:19:19
 */
public class OneInterfaceImpl implements OneInterface {
    public static final String name="OneInterfaceImpl";
    @Override
    public void say() {
        System.out.println("Hello World!");
    }
}

InterfaceTest

/**
 * @author LJW
 * @project testjava
 * @package polymorphic
 * @file  InterfaceTest.java
 * @time 2017-12-15 21:20:20
 */
public class InterfaceTest {
    public static void main(String[] args) {
        OneInterface oneInterface= new OneInterfaceImpl();
        oneInterface.say();
        System.out.println(oneInterface.name);  //不建议这样写(类.变量) static
    }
}

结果：

什么是IoC?

IoC(Inversion of Control):控制反转，控制权的转移，应用程序本身不负责依赖对象的创建和维护，而是由外部容器负责创建和维护。

http://blog.csdn.net/qq_22654611/article/details/52606960

这位大佬解释的比较好。引用解释下感谢：

  • 谁控制谁，控制什么：传统Java SE程序设计，我们直接在对象内部通过new进行创建对象，是程序主动去创建依赖对象；而IoC是有专门一个容器来创建这些对象，即由Ioc容器来控制对 象的创建；谁控制谁？当然是IoC 容器控制了对象；控制什么？那就是主要控制了外部资源获取（不只是对象包括比如文件等）。
  • 为何是反转，哪些方面反转了：有反转就有正转，传统应用程序是由我们自己在对象中主动控制去直接获取依赖对象，也就是正转；而反转则是由容器来帮忙创建及注入依赖对象；为何是反转？因为由容器帮我们查找及注入依赖对象，对象只是被动的接受依赖对象，所以是反转；哪些方面反转了？依赖对象的获取被反转了。

The Spring Ioc container

当有了IoC/DI的容器后，在客户端类中不再主动去创建这些对象了。

DI(依赖注入)是其一种实现方式，目的是创建对象并且组装对象之间的关系。再引用下那位大佬的话解释下：

IoC的一个重点是在系统运行中，动态的向某个对象提供它所需要的其他对象。这一点是通过DI（Dependency Injection，依赖注入）来实现的。比如对象A需要操作数据库，以前我们总是要在A中自己编写代码来获得一个Connection对象，有了 spring我们就只需要告诉spring，A中需要一个Connection，至于这个Connection怎么构造，何时构造，A不需要知道。在系统运行时，spring会在适当的时候制造一个Connection，然后像打针一样，注射到A当中，这样就完成了对各个对象之间关系的控制。A需要依赖 Connection才能正常运行，而这个Connection是由spring注入到A中的，依赖注入的名字就这么来的。那么DI是如何实现的呢？ Java 1.3之后一个重要特征是反射（reflection），它允许程序在运行的时候动态的生成对象、执行对象的方法、改变对象的属性，spring就是通过反射来实现注入的。

引用
总结：控制反转IoC(Inversion of Control)是说创建对象的控制权进行转移，以前创建对象的主动权和创建时机是由自己把控的，而现在这种权力转移到第三方，比如转移交给了IoC容器，它就是一个专门用来创建对象的工厂，你要什么对象，它就给你什么对象，有了 IoC容器，依赖关系就变了，原先的依赖关系就没了，它们都依赖IoC容器了，通过IoC容器来建立它们之间的关系。(获取依赖对象的过程被反转了）。

Spring的Bean配置

Spring提供了三种实例化Bean的方式

http://blog.csdn.net/yerenyuan_pku/article/details/52832793
http://blog.csdn.net/flqljh/article/details/49834609

感谢感谢！

  • 使用类构造器实例化(主流)
  • 使用静态工厂方法实例化
  • 使用实例工厂方法实例化

Bean容器初始化

基础：两个包

org.springframework.beans

BeanFactory提供配置结构和基本功能，加载并初始化Bean

org.springframework.context

ApplicationContext保存了Bean对象并在Spring中被广泛使用

方式：本地文件、Classpath、Web应用中依赖servlet或Listener

posted @ 2017-12-15 00:32  罗贱人  阅读(174)  评论(0)  编辑  收藏  举报