java--Spring

1.什么是Spring?特点是什么？优点是什么？

Spring是Java EE编程领域的一个轻量级开源框架，该框架由一个叫Rod Johnson的程序员在 2002 年最早提出并随后创建，是为了解决企业级编程开发中的复杂性，实现敏捷开发的应用型框架 。Spring是一个开源容器框架，它集成各类型的工具，通过核心的Beanfactory实现了底层的类的实例化和生命周期的管理。在整个框架中，各类型的功能被抽象成一个个的 Bean，这样就可以实现各种功能的管理，包括动态加载和切面编程。

特点：
1.方便解耦，简化开发
通过Spring提供的IoC容器，我们可以将对象之间的依赖关系交由Spring进行控制，避免硬编码所造成的过度程序耦合。有了Spring，用户不必再为单实例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。
2.AOP编程的支持
通过Spring提供的AOP功能，方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通过AOP轻松应付。
3.声明式事务的支持
在Spring中，我们可以从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活地进行事务的管理，提高开发效率和质量。
4.方便程序的测试
可以用非容器依赖的编程方式进行几乎所有的测试工作，在Spring里，测试不再是昂贵的操作，而是随手可做的事情。例如：Spring对Junit4支持，可以通过注解方便的测试Spring程序。
5.方便集成各种优秀框架
Spring不排斥各种优秀的开源框架，相反，Spring可以降低各种框架的使用难度，Spring提供了对各种优秀框架（如Struts,Hibernate、Hessian、Quartz）等的直接支持。
6.降低Java EE API的使用难度
Spring对很多难用的Java EE API（如JDBC，JavaMail，远程调用等）提供了一个薄薄的封装层，通过Spring的简易封装，这些Java EE API的使用难度大为降低。
7.Java 源码是经典学习范例
Spring的源码设计精妙、结构清晰、匠心独运，处处体现着大师对Java设计模式灵活运用以及对Java技术的高深造诣。Spring框架源码无疑是Java技术的最佳实践范例。如果想在短时间内迅速提高自己的Java技术水平和应用开发水平，学习和研究Spring源码将会使你收到意想不到的效果。

优点:
1.低侵入式设计，代码的污染极低。
2.独立于各种应用服务器，基于Spring框架的应用，可以真正实现Write Once，Run Anywhere的承诺。
3.Spring的IOC容器降低了业务对象替换的复杂性，提高了组件之间的解耦。
4.Spring的AOP支持允许将一些通用任务如安全、事务、日志等进行集中式管理，从而提供了更好的复用。
5.Spring的ORM和DAO提供了与第三方持久层框架的良好整合，并简化了底层的数据库访问。
6.Spring的高度开放性，并不强制应用完全依赖于Spring，开发者可自由选用Spring框架的部分或全部。

2.什么是耦合？

也称块间联系。指软件系统结构中各模块间相互联系紧密程度的一种度量。模块之间联系越紧密，其耦合性就越强，模块的独立性则越差。模块间耦合高低取决于模块间接口的复杂性、调用的方式及传递的信息。

3.Spring的核心是什么？

Spring的核心是IOC和AOP。

4.IOC的含义是什么?

IOC就是控制反转，是指创建对象的控制权的转移，以前创建对象的主动权和时机是由自己把控的，而现在这种权力转移到Spring容器中，并由容器根据配置文件去创建实例和管理各个实例之间的依赖关系，对象与对象之间松散耦合，也利于功能的复用。

5.什么是DI？和IOC有什么区别?

DI是IOC的技术的实现。
DI:依赖注入，只需要在程序中提供要使用的对象名称就可以了,至于对象如何在容器中创建，赋值，查找都由容器内部实现。
指容器复制创建和维护对象之间的依赖关系，而不是通过对象本身复制自己的创建和解决自己的依赖。控制反转是通过依赖注入实现的。
区别：IOC:控制反转,将类的对象的创建交给Spring类管理创建.
DI:依赖注入,将类里面的属性在创建类的过程中给属性赋值.

6.属性注入的方式？

构造函数注入

1）建立一个User类

public class User {

    private String name;
    private Integer age;

     public User(String name, Integer age){
         this.name = name;
         this.age = age;
     }


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

2） 配置xml文件

<!--bean的构造方法的属性注入-->
    <bean id="user" class="com.openlab.bean.User">
        <constructor-arg name="name" value="李四"/>
        <constructor-arg name="age" value="23"/>
    </bean>

3）编写一个测试类

public void demo1(){
        ApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("applicationContext.xml");
        User user =  (User)applicationContext.getBean("user");
        System.out.println(user);

     }

4） 运行结果

User{name='李四', age=23}

属性setter方法注入

1）建立一个Person 类

public class Person {
    private String name;
    private Integer age;

    private Cat cat;

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public Cat getCat() {
        return cat;
    }

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

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", cat=" + cat +
                '}';
    }
}

2. 建立一个Cat类

public class Cat {

    private String name;

    public String getName() {
        return name;
    }

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

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

3）配置xml文件

 <!--bean的set方法注入-->
    <bean id="person" class="com.openlab.bean.Person">
        <property name="name" value="jack"/>
        <property name="age" value="20"/>
         <!--引用需要用ref -->
        <property name="cat" ref="cat"/>

    </bean>

    <bean id="cat" class="com.openlab.bean.Cat">
        <property name="name" value="ketty" />

    </bean>

3）测试类

public void demo2(){
        ApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("applicationContext.xml");
        Person person  = (Person)applicationContext.getBean("person");
         System.out.println(person);
     }

4） 结果

Person{name='jack', age=20, cat=Cat{name='ketty'}}

Bean 的p命名空间的属性注入

7.如何注入集合属性

@Setter
@Getter
@AllArgsConstructor
@NoArgsConstructor
public class collectiontDI {
    private String[] arr;
    private List<String> list;
    private Map<String,String> map;
    private Set<String> set;

}

<bean class="com.openlab.bean.collectiontDI" id="collectiontDI">
        <property name="arr">
            <array>
                <value>张三丰</value>
                <value>里斯</value>
                <value>王f五i</value>
            </array>
        </property>
        <property name="list">
            <list>
            <value>数据库</value>
            <value>前端</value>
            <value>web</value>
            </list>
        </property>

    <property name="map">
        <map>
            <entry key="cn" value="China"></entry>
            <entry key="en" value="England"></entry>
            <entry key="jp" value="Jpapan"></entry>
        </map>
    </property>
        <property name="set">
            <set>
                <value>数据库</value>
                <value>前端</value>
                <value>web</value>
            </set>
        </property>
    </bean>

8.spring管理bean的作用域

singleton作用域
如果一个 bean 的作用域被声明为 singleton，那么 Spring IOC 容器将只创建一个该对象的实例，并将其存储在缓存中。每次请求该 bean 时，都会返回该缓存对象。Singleton 作用域是所有 bean 的默认作用域。
prototype作用域
如果一个 bean 的作用域被声明为 prototype，那么每次请求该 bean 时，Spring IOC 都会返回一个新的实例。

9.spring管理bean的生命周期

1.五个
1.创建对象
2.set方法
3.init方法
4.对象正常使用
5.destroy方法

2.七个
1：调用无参方法
2：set方法调用
3：init()方法前被调用
4：init（）方法被调用
5：init（）方法后被调用
6：对象可以正常使用
7：destroy（）方法被调用

10.spring中bean的两种方式

1.普通bean
2.工厂bean

public class MyFactor yBeanimp lements Factor yBean<Emp>{
 @Overr ide
  public Emp get0bject() throws Exception {
      return new Emp() ;
  }
  @Overr ide
  public Class<?> get0bjectType() {
     return Emp. class;
  }
}
<bean id=" factoryBean" class="....."></bean> ctx. getBean()//获取的是emp类型