Spring 笔记自整理01

Spring 笔记01

1. 搭建Spring项目
（1）创建项目，加载依赖

<ependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>4.3.7.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>4.3.7.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>4.3.7.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context-support</artifactId>
        <version>4.3.7.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-expression</artifactId>
        <version>4.3.7.RELEASE</version>
    </dependency>


    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.14</version>
    </dependency>
</dependencies>

（2）在resources中新建配置文件
文件名官方推荐------applicationContext.xml
新建方式：在resources右击->New->XML Configuration File->Spring Config然后会出现
点击Configure application context->create new application context->ok就完成啦！

2. Spring框架特征实例
(1) 工厂分为静态工厂和非静态工厂
创建对象的实例：

public class PeersonFactory {
    //创建person的静态方法
    public static Person createPerson(){
        System.out.println("通过静态工厂创建了对象");
        return new Person(123,"小乔","女");
    }
}

public class NoStaticPeersonFactory {
    //创建person的非静态方法
    public Person createPerson(){
        System.out.println("通过非静态工厂创建了对象");
        return new Person(123,"小乔","女");
    }
}

<!--name="person,person2"相当于小名
可以取多个值 但是不能重复
id：不可以重复且不能使用特殊字符
lazy-init表示对象的加载时机（true（使用对象的时候才创建）；false（spring框架一启动就加载））-->
<!--方式1.无参构造方法创建对象-->
<bean id="p1" name="person1,person2" class="com.swjd.bean.Person"
      scope="singleton" lazy-init="true" init-method="init" destroy-method="destroy">
    <!--  DI-依赖注入（给对象赋值）-->
    <property name="id" value="975"></property>
    <property name="name" value="貂蝉"></property>
    <property name="sex" value="女"></property>
 </bean>
<!--scope="prototype"：表示创建对象的规则变成多例-->
<bean id="p2" name="person3,person4" class="com.swjd.bean.Person" scope="prototype">
    <!--  DI-依赖注入（给对象赋值）-->
    <property name="id" value="857"></property>
    <property name="name" value="虞姬"></property>
    <property name="sex" value="女"></property>
</bean>
<!--方式2.用带参的构造方法创建对象-->
<bean id="p3" class="com.swjd.bean.Person">
    <constructor-arg index="0" type="int" value="9528"></constructor-arg>
    <constructor-arg index="1" type="java.lang.String" value="蔡文姬"></constructor-arg>
    <constructor-arg index="2" type="java.lang.String" value="女"></constructor-arg>
</bean>
<!--方式3.用静态工厂创建对象-->
<bean id="p4" class="com.swjd.beanfactory.PeersonFactory" factory-method="createPerson">
</bean>
<!--方式4.用非静态工厂创建对象-->
<bean id="noStaticFactory" class="com.swjd.beanfactory.NoStaticPeersonFactory" ></bean>
<bean id="p5" factory-bean="noStaticFactory" factory-method="createPerson"></bean>

(2) IoC Inverse of Control 反转控制的概念，就是将原本在程序中手动创建UserService对象的控制权，交由Spring框架管理，简单说，就是创建UserService对象控制权被反转到了Spring框架。（对象从容器里拿出来而不是通过new出来）

(3) DI：Dependency Injection 依赖注入，在Spring框架负责创建Bean对象时，动态的将依赖对象注入到Bean组件

Spring依赖注入的5种方式

1. 调用set方法注入
    2.通过带参的构造方法
    3.P命名空间注入（本质还是set注入，语法更简洁）
    4.SPEL表达式注入
    5.复杂类型的注入：1）注入对象
                       2）注入数组
                       3）注入集合
                       4）注入Map实例：

先创建一个Dog类、Student类和Man类。
以下为applicationContext.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" xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--创建对象-->
    <bean id="d1" class="com.swjd.bean.Dog">
        <property name="id" value="1"></property>
        <property name="name" value="genki"></property>
        <property name="sex" value="公"></property>
    </bean>
    <!--第一种：set注入-->
    <bean id="m1" class="com.swjd.bean.Man">
        <property name="id" value="1"></property>
        <property name="name" value="管田将晖"></property>
        <property name="age" value="27"></property>
        <!--<property name="dog" ref="d1"></property>-->
        <property name="dog">
            <ref bean="d1"></ref>
        </property>
    </bean>
    <!--第二种：通过带参的构造方法-->
    <bean id="m2" class="com.swjd.bean.Man">
        <constructor-arg index="0" type="int" value="2"></constructor-arg>
        <constructor-arg index="1" type="java.lang.String" value="Jerry"></constructor-arg>
        <constructor-arg index="2" type="int" value="21"></constructor-arg>
        <constructor-arg index="3" type="com.swjd.bean.Dog" ref="d1"></constructor-arg>
    </bean>
    <!--第三种：P命名空间注入-->
    <bean id="m3" class="com.swjd.bean.Man" p:id="3" p:name="猪八戒" p:age="108" p:dog-ref="d1"></bean>

    <!--第四种：SPEL表达式注入-->
    <bean id="m4" class="com.swjd.bean.Man">
        <property name="id" value="#{m1.id}"></property>
        <property name="name" value="#{m3.name}"></property>
        <property name="age" value="#{m1.age}"></property>
    </bean>

</beans>

以下为第五种复杂类型的注入：

<?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="s1" class="com.swjd.bean.Student">
        <property name="name" value="小松菜奈"></property>
        <property name="hobbies">
            <array>
                <value>拍照</value>
                <value>演戏</value>
                <value>苏打</value>
            </array>
        </property>
        <property name="subject">
            <list>
                <value>Spring</value>
                <value>MyBatis</value>
            </list>
        </property>
        <property name="map">
            <map>
                <entry key="Chinese">
                    <value>95</value>
                </entry>
                <entry key="Math">
                    <value>100</value>
                </entry>
            </map>
        </property>
    </bean>
</beans>

（5）测试

public class MyTest {
    public static void main(String[] args) {
        //1.启动Spring容器
        ClassPathXmlApplicationContext context=
                new ClassPathXmlApplicationContext("applicationContext.xml");
        //2.拿对象
        System.out.println(context.getBean("m1", Man.class));
        System.out.println(context.getBean("m2", Man.class));
        System.out.println(context.getBean("m3", Man.class));
        System.out.println(context.getBean("m4", Man.class));
    }
}

面试小问题

1.IoC 和 DI的区别？

IoC 控制反转，指将对象的创建权，反转到Spring容器， DI
依赖注入，指Spring创建对象的过程中，将对象依赖属性通过配置进行注入

2.BeanFactory 接口和 ApplicationContext 接口有什么区别？

①ApplicationContext 接口继承BeanFactory接口，Spring核心工厂是BeanFactory,BeanFactory采取延迟加载，第一次getBean时才会初始化Bean, ApplicationContext是会在加载配置文件时初始化Bean。
②ApplicationContext是对BeanFactory扩展，它可以进行国际化处理、事件传递和bean自动装配以及各种不同应用层的Context实现

开发中基本都在使用ApplicationContext, web项目使用WebApplicationContext，很少用到BeanFactory

3.spring配置bean实例化有哪些方式？

1）使用类构造器实例化(默认无参数)

<bean id="bean1" class="cn.itcast.spring.b_instance.Bean1"></bean>

2）使用静态工厂方法实例化(简单工厂模式)

//下面这段配置的含义：调用Bean2Factory的getBean2方法得到bean2
<bean id="bean2" class="cn.itcast.spring.b_instance.Bean2Factory" factory-method="getBean2"></bean>

3）使用实例工厂方法实例化(工厂方法模式)

//先创建工厂实例bean3Facory，再通过工厂实例创建目标bean实例
<bean id="bean3Factory" class="cn.itcast.spring.b_instance.Bean3Factory"></bean>
<bean id="bean3" factory-bean="bean3Factory" factory-method="getBean3"></bean>

4.Spring的核心类有哪些，各有什么作用？

BeanFactory：产生一个新的实例，可以实现单例模式 BeanWrapper：提供统一的get及set方法
ApplicationContext:提供框架的实现，包括BeanFactory的所有功能

5.Spring里面如何配置数据库驱动？
用”org.springframework.jdbc.datasource.DriverManagerDataSource”数据源来配置数据库驱动。示例如下：

<bean id=”dataSource”> 
    <property name=”driverClassName”> 
        <value>org.hsqldb.jdbcDriver</value>
    </property> 

    <property name=”url”> 
        <value>jdbc:hsqldb:db/appfuse</value> 
    </property> 
    <property name=”username”><value>abc</value></property> 
    <property name=”password”><value>abc</value></property> 
</bean>

6.解释一下Spring AOP里面的几个名词

1.切面（Aspect）：一个关注点的模块化，这个关注点可能会横切多个对象。事务管理是J2EE应用中一个关于横切关注点的很好的例子。在Spring AOP中，切面可以使用通用类（基于模式的风格）或者在普通类中以 @Aspect 注解（@AspectJ风格）来实现。

2.连接点（Joinpoint）：在程序执行过程中某个特定的点，比如某方法调用的时候或者处理异常的时候。在Spring AOP中，一个连接点总是代表一个方法的执行。
通过声明一个org.aspectj.lang.JoinPoint类型的参数可以使通知（Advice）的主体部分获得连接点信息。

3.通知（Advice）：在切面的某个特定的连接点（Joinpoint）上执行的动作。通知有各种类型，其中包括“around”、“before”和“after”等通知。
通知的类型将在后面部分进行讨论。许多AOP框架，包括Spring，都是以拦截器做通知模型，并维护一个以连接点为中心的拦截器链。

4.切入点（Pointcut）：匹配连接点（Joinpoint）的断言。通知和一个切入点表达式关联，并在满足这个切入点的连接点上运行（例如，当执行某个特定名称的方法时）。
切入点表达式如何和连接点匹配是AOP的核心：Spring缺省使用AspectJ切入点语法。

5.引入（Introduction）：（也被称为内部类型声明（inter-type declaration））。声明额外的方法或者某个类型的字段。
Spring允许引入新的接口（以及一个对应的实现）到任何被代理的对象。例如，你可以使用一个引入来使bean实现 IsModified
接口，以便简化缓存机制。
6.目标对象（Target Object）：被一个或者多个切面（aspect）所通知（advise）的对象。也有人把它叫做被通知（advised）对象。既然Spring AOP是通过运行时代理实现的，这个对象永远是一个被代理（proxied）对象。

7.AOP代理（AOP Proxy）： AOP框架创建的对象，用来实现切面契约（aspect contract）（包括通知方法执行等功能）。在Spring中，AOP代理可以是JDK动态代理或者CGLIB代理。注意：Spring
2.0最新引入的基于模式（schema-based）风格和@AspectJ注解风格的切面声明，对于使用这些风格的用户来说，代理的创建是透明的。

8.织入（Weaving）：把切面（aspect）连接到其它的应用程序类型或者对象上，并创建一个被通知（advised）的对象。这些可以在编译时（例如使用AspectJ编译器），类加载时和运行时完成。 Spring和其他纯Java AOP框架一样，在运行时完成织入。

Mora然染

发布了2 篇原创文章 · 获赞 0 · 访问量 17

私信关注