疯狂java


您现在的位置: 疯狂软件 >> 新闻资讯 >> 正文

Spring学习笔记


 

1. 使用setter方法和构造方法装配Bean
 
1.1 前期准备
 
使用setter方法注入依赖其实在上一篇中已经遇到过了主要通过property在bean中进行注入
 
    <!--声明一个bean并且指定相应的类-->
    <bean name="dog" class="cn.lger.domain.Dog">
        <property name="name" value="小美"/>
        <property name="breed" value="土狗"/>
        <property name="sex" value="母"/>
    </bean>
上面在bean中使用 property 进行配置,用法是<property name="对象中的属性名" value="基本类型(与属性相互对应)">
但是,除了基本类型,对象这些复杂类型要怎么办?
 
比如有下面的一个实体类:Man
 
public class Man {
 
    private Dog dog;
    private Dog dog2;
 
    /**
     * 这里因为使用了有参的构造函数,所以需要写入无参构造函数
     */
    public Man(){
 
    }
    /**
     * 提供给Spring容器进行注入dog属性,这里将值赋值给dog2
     */
    public Man(Dog dog) {
        this.dog2 = dog;
    }
    
    public Dog getDog() {
        return dog;
    }
 
    public void setDog(Dog dog) {
        this.dog = dog;
    }
 
    public void walkTheDog(){
        System.out.println("遛"+dog.getName());
        System.out.println("遛"+dog2.getName());
    }
}
这个Man有两只Dog,此人要去遛狗,我们现在就帮助他获得dog
这里我们在配置文件中配置两个dog的bean,配置如下:
 
    <bean name="dog" class="cn.lger.domain.Dog">
        <property name="name" value="小美"/>
        <property name="breed" value="土狗"/>
        <property name="sex" value="母"/>
    </bean>
 
    <bean name="dog2" class="cn.lger.domain.Dog">
        <property name="name" value="小美2"/>
        <property name="breed" value="土狗"/>
        <property name="sex" value="母"/>
    </bean>
这里是关于Man获取到两只dog的过程,也是bean的装配过程,Man这个bean的声明过程
 
    <bean name="man" class="cn.lger.domain.Man">
        <!--通过ref映射将dog属性注入-->
        <property name="dog" ref="dog"/>
        <!--通过构造函数注入-->
        <constructor-arg ref="dog2"/>
    </bean>
首先我们是使用了setter方法注入我们的bean-->dog,这里我们只需要将value改为ref 就可以使用复杂类型的注入工作了,但是有一个前提是你所需要注入的bean当然是由Spring管理了
然后是使用了构造函数进行注入,这里就要求我们在生成JavaBean的使用需要提供相应的构造方法,上面给出的Man中有注释,经过构造方法后dog2属性将会产生一个叫小美2 的狗狗
 
1.2 代码测试
 
public class TestWiring {
 
    /**
     * 测试通过xml文件装配Bean到Man类
     */
     @Test
    public void test01(){
        ClassPathXmlApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        Man man = applicationContext.getBean(Man.class);
        man.walkTheDog();
    }
}
 
//打印结果:遛小美
//        遛小美2
当我们的Man 去遛狗walkTheDog()的时候这时候控制台打印的信息遛小美 遛小美2 让我们知道注入成功了
 
1.3 小结
 
我们需要明白,可以使用Spring这种在获取对象之前容器的加工能力获取一个有初始值的对象,可以方便我们的开发。每一个获取到的Bean都需要初始值的话这样我们可以解放很多劳动力,装配还可以通过SpEL(Spring Expression Language)这种表达式去注入一些东西,比如:dog2中的<property name="sex" value="#{dog.sex}"/>,当然了,如果有机会的话我们可以一起探讨一下这个东西
还有就是,这里我所给出的装配Bean是一个简单的装配工作,还有集合(List、Map....)、工厂等方面的装配没有多做介绍,下面文章结束时会给出链接,里面会有装配方面更为详细的解释和操作:-)
 
2. AOP的使用
 
2.1 前期准备
 
在编程之前我们需要了解几个概念,这些概念性的东西我不是很喜欢,它总是让人混淆,或者有点烦。这里我用了自己的理解方式去解释
 
通知(Advice): 这可以理解为一段代码片,这段代码要让很多没有联系的对象用上,比如数据库中的连接开启与关闭,日志功能等,我们把这些代码使用Spring AOP用在其他对象的方法之前或者之后,这些代码块就可以称之为通知
 
连接点(Joincut): 就是对象方法在使用时是能通过Spring调用通知的地方叫做连接点
 
切点(Pointcut): 就是对象方法在使用时是明确通过Spring调用通知的地方叫做切点,就是说已经能够基本的确定这里需要插入一个通知了
切面(Aspect): 切面是切点和通知的结合,就是说一个切面就是通过通知 知道要干什么和切点的在哪里干
 
织入(Weaving): 织入可以理解成一个过程,是通知被应用到到切点的这一个过程
 
看了以上的概念是不是对于AOP有了犯迷糊,是这样的,概念的东西还是需要捣鼓一下,其实我也不是很了解,但是,我们要用实例、实践去增加我们的理解,如果别人要我们解释总不能一行一行代码的说出来,同行之间总是要用一些术语交流的嘛,好,废话不说,继续AOP。
我们现在有一个Man,他现在要去上班了,但是又要去遛狗!!怎么办?可以请一个代理人啊,帮我们的Man去遛狗就行了。
 
pom.xml代码如下:
 
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
 
    <groupId>cn.lger</groupId>
    <artifactId>spring-demo</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>spring-base</module>
    </modules>
 
    <properties>
        <spring.version>4.3.10.RELEASE</spring.version>
    </properties>
 
    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
 
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
 
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
 
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>
 
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>${spring.version}</version>
        </dependency>
 
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!--需要使用aop除了引入以上核心部分还要引入下面的两个依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>
 
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>${spring.version}</version>
        </dependency>
 
    </dependencies>
 
 
</project>
Man的代码如下:
 
public class Man {
 
    public void noFreeTime(){
        System.out.println("狗主人(被代理人)上班了");
    }
 
}
代理人Proxy的代码如下:
 
public class Proxy {
 
    public void before(){
        System.out.println("代理人去被代理人家里牵狗,然后遛狗");
    }
 
    public void after(){
        System.out.println("代理人带狗狗回家");
    }
 
}
配置文件如下:
 
<?xml version="1.0" encoding="UTF-8"?>
<!--因为需要用到aop,所以需要引入新的约束,与上一篇的略有不同-->
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.0.xsd ">
 
 
    <bean name="man" class="cn.lger.domain.Man" />
 
    <!--这是一个代理遛狗的人-->
    <bean class="cn.lger.proxy.Proxy" name="proxy"/>
 
    <!--
        关于aop:pointcut的规则
        <aop:pointcut id="walkTheDog" expression="execution(* cn.lger.domain.Man.noFreeTime())"/>
        id->pointcut标识,具有唯一性
        expression是填入一个表达式,表达式中可以使用的有execution()/within()...
        我们这里使用的是execution(),里面的填入是一个关于切入点的信息比如我要Man中的所有方法都能被代理则
        我们可以一步步推出来,如下:
        void cn.lger.domain.Man.noFreeTime()//public 可以不写
        * cn.lger.domain.Man.noFreeTime()//* 返回任意类型
        * cn.lger.domain.Man.*(..)//任意方法、任意参数
    -->
    <!--配置aop-->
    <aop:config>
        <!--切入点-->
        <aop:pointcut id="walkTheDog" expression="execution(* cn.lger.domain.Man.*(..))"/>
        <!--切面-->
        <aop:aspect id="proxy" ref="proxy">
            <aop:before method="before" pointcut-ref="walkTheDog"/>
            <aop:after method="after" pointcut-ref="walkTheDog"/>
            <!--这里的method除了上面的after和before还有其他的,可以google或者百度,当然看文档也是可以的-->
        </aop:aspect>
 
    </aop:config>
 
 
</beans>
2.2 代码测试
 
    /**
     * 测试AOP是否配置成功
     */
    @Test
    public void test01(){
        ClassPathXmlApplicationContext context =
                new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        Man man = context.getBean(Man.class);
        man.noFreeTime();
    }
    //打印结果
    //    代理人去被代理人家里牵狗,然后遛狗
    //    狗主人上班了
    //    代理人带狗狗回家
通过以上的代码测试,说明了在执行noFreeTime()的时候就会执行我们在配置中配置的proxy.before()和proxy.after()方法。为什么会这样,这其实和我们Java学习中的动态代理是差不多的,但是Spring的实现更为复杂,它不要求我们实现什么接口,它是基于cglib动态代理的,这里就不作展开,可以自己了解。