Spring1

一、Spring是什么？有什么用？

　　Spring的适用环境是这样的，假设现在有一个类port,它将提供一个返回消息的功能，代码如下：

public class port {
    private weiboMessage weiboMessage;
 
    public port(weiboMessage weiboMessage){
        this.weiboMessage = weiboMessage;
    }
    public String getMessage(){
        return weiboMessage.getMessage();
    }
}

　　从getMessage方法中我们可以看到，返回的消息是通过weiboMessage这个对象的完成的，所以这个port类功能的实现，是需要在其内部创建这样一个对象，在这样的场景中port称作被注入对象，weiboMessage称作被依赖对象。

　　在开发的时候一个类的实现通常需要依赖其他对象，有时候还会出现这样的实现方法（其实大多数时候是这样实现的）：

    public String getMessage(){
        weiboMessage weiboMessage = new weiboMessage();
        return weiboMessage.getMessage();
    }

　　在使用的时候再来创建这个对象，这样的主动的去获取对象其实是没有必要的，如果依赖的对象过多的话我们应该考虑转变依赖对象的方式。

　　在Spring中Ioc容器实现的就是改变我们使用依赖对象的方式，像上面那样被注入对象会直接依赖于被依赖对象，在Ioc中，Ioc将承担提供依赖对象的服务，所有的被注入对象和被依赖对象都将被Ioc所管理，被注入的对象需要什么就跟Ioc要。

二、注入方式

　　依赖注入的方式有三种，构造方法注入、setter方法注入和接口注入，这里就说一下前两种吧，因为接口注入我觉得好麻烦==

• 构造方法注入

public class port {
    private weiboMessage weiboMessage;
 
    public port(weiboMessage weiboMessage){
        this.weiboMessage = weiboMessage;
    }
    ......
}    

　　这中场景下Ioc将会扫描被注入对象的构造方法，从而获取它的依赖对象列表，从而进行对象注入。

　　这种方法注入方式比较直观，对象构造完成就处于就绪状态，随时都可以使用。

• setter方法注入

public class port {
 
    private weiboMessage weiboMessage;
 
    public void setWeiboMessage(weiboMessage weiboMessage) {
        this.weiboMessage = weiboMessage;
    }
    ......
}

　　这样外界可以通过调用setter方法为被注入对象注入所依赖的对象了。这样可以在对象构造完成后再注入对象。

三、使用配置文件的方式实现依赖注入（xml方式）

　　首先创建一个表示功能的接口：

public interface port {
    String getMessage();
}

　　然后是实现该接口的两个类（注入方式不同）：

public class portAImpl implements port {
 
    private weiboMessage weiboMessage;
 
    public portAImpl(weiboMessage weiboMessage) {
        this.weiboMessage = weiboMessage;
    }
 
    @Override
    public String getMessage() {
        return "A: " + weiboMessage.toString();
    }
}

public class portBImpl implements port {
 
    private weiboMessage weiboMessage;
 
    public void setWeiboMessage(weiboMessage weiboMessage) {
        this.weiboMessage = weiboMessage;
    }
 
    @Override
    public String getMessage() {
        return "B: " + weiboMessage.toString();
    }
}

　　然后是weiboMessage这个类的实现，

public class weiboMessage {
    private int id;
    private String date;
    private String message;
 
    public weiboMessage(int id,String date,String message){
        this.id = id;
        this.date = date;
        this.message = message;
    }
    public long getId() {
        return id;
    }
 
    public void setId(int id) {
        this.id = id;
    }
 
    public String getDate() {
        return date;
    }
 
    public void setDate(String date) {
        this.date = date;
    }
 
    public String getMessage() {
        return message;
    }
 
    public void setMessage(String message) {
        this.message = message;
    }
 
    @Override
    public String toString() {
        return "id: " + id +
                "date: " + date +
                "message " + message;
    }
}

　　这样就实现了一个被依赖类weiboMessage，两个被注入类portAImpl和portBImpl。再然后是配置文件applicationContext.xml的编写：

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-4.1.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd">
 
    <bean id="portA" class="com.ssh.respository.impl.portAImpl">
        <constructor-arg>
            <ref bean="weibomessage"/>
        </constructor-arg>
    </bean>
 
    <bean id="portB" class="com.ssh.respository.impl.portBImpl">
        <property name="weiboMessage">
            <ref bean="weibomessage"/>
        </property>
    </bean>
 
    <bean id="weibomessage" class="com.ssh.respository.weiboMessage">
        <constructor-arg value="233"/>
        <constructor-arg value="2018.3.26"/>
        <constructor-arg value="a message"/>
    </bean>
 
</beans>

　　<bean>....</bean>这样的标签就定义了一个类，Ioc中将会记录这个对象的信息，信息包括class类型、是否为抽象对象、构造方法参数及其他属性等。然后就可以根据id向Ioc发出请求就能得到相应的对象。

　　先看id为weibomessage的中的<constructor-arg>标签表示将使用构造方法进行注入，这里根据构造方法中输入参数的顺序依次进行赋值，id=233，date=2018.3.26，message=a message。

　　id为portA也同样类似，不过它注入的对象是已经在Ioc容器中已经被注册的类，所以<constructor-arg>标签中的<ref>标签中的bean属性值将是已被注册类的id

　　前两个都是使用构造方法进行注入的，id为portB的就是使用setter方法进行注册的，使用的是<property>标签，name的值与setter方法的名字有关，bean就是id。

　　这样就算配置完成了，然后是测试类：

public class test {
    public static void main(String[] args){
        ApplicationContext context = new ClassPathXmlApplicationContext("/META-INF/applicationContext.xml");
        port A = (port)context.getBean("portA");
        port B = (port)context.getBean("portB");
 
        System.out.println(A.getMessage());
        System.out.println(B.getMessage());
    }
}

　　运行结果是：

A: id: 233date: 2018.3.26message a message
B: id: 233date: 2018.3.26message a message

　　最后的使用分为以下两步：

　　第一步是我们使用框架 API ClassPathXmlApplicationContext() 来创建应用程序的上下文。这个 API 加载 beans 的配置文件并最终基于所提供的 API，它处理创建并初始化所有的对象，即在配置文件中提到的 beans。

　　第二步是使用已创建的上下文的 getBean() 方法来获得所需的 bean。这个方法使用 bean 的 ID 返回一个最终可以转换为实际对象的通用对象。一旦有了对象，你就可以使用这个对象调用任何类的方法。

　　

　　最后给一张这次的demo的项目结构吧，部署这种框架的时候也是经常在项目结构上出错，不过并不就是说我这个项目结构就是正确的，只是能运行而已：

　　蓝色标注的是我这次用到的，其他的是多余的没必要在意。