使用setter方法和构造方法装配Bean

本篇就简单的说一下Bean的装配和AOP
本篇的项目是在上一篇我的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）： 织入可以理解成一个过程，是通知被应用到到切点的这一个过程

当然了你可以去看下别人对这些概念的解释
http://www.cnblogs.com/hongwz/p/5764917.html
http://www.importnew.com/20748.html

看了以上的概念是不是对于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动态代理的,这里就不作展开，可以自己了解。

blog.163.com/lgchqq4t5p/blog/static/27907352620178224634280/
blog.163.com/lgchqq4t5p/blog/static/27907352620178224630779/
blog.163.com/lgchqq4t5p/blog/static/27907352620178224627401/
blog.163.com/lgchqq4t5p/blog/static/27907352620178224623964/
blog.163.com/lgchqq4t5p/blog/static/27907352620178224620645/
blog.163.com/ao89r8i4oa/blog/static/27908633120178224615933/
blog.163.com/ao89r8i4oa/blog/static/27908633120178224612548/
blog.163.com/ao89r8i4oa/blog/static/2790863312017822469359/
blog.163.com/ao89r8i4oa/blog/static/279086331201782246622/
blog.163.com/ao89r8i4oa/blog/static/2790863312017822462616/
blog.163.com/cwgv7rdxj5/blog/static/2790863262017822455831/
blog.163.com/cwgv7rdxj5/blog/static/27908632620178224554266/
blog.163.com/cwgv7rdxj5/blog/static/27908632620178224550684/
blog.163.com/cwgv7rdxj5/blog/static/27908632620178224547207/
blog.163.com/cwgv7rdxj5/blog/static/27908632620178224543667/
blog.163.com/vaiw8kblf1/blog/static/27907652020178224538275/
blog.163.com/vaiw8kblf1/blog/static/27907652020178224534630/
blog.163.com/vaiw8kblf1/blog/static/27907652020178224531366/
blog.163.com/vaiw8kblf1/blog/static/27907652020178224526862/
blog.163.com/vaiw8kblf1/blog/static/27907652020178224523704/
blog.163.com/rqivmjcr3n/blog/static/27907651720178224519123/
blog.163.com/rqivmjcr3n/blog/static/27907651720178224515767/
blog.163.com/rqivmjcr3n/blog/static/27907651720178224512427/
blog.163.com/rqivmjcr3n/blog/static/2790765172017822459198/
blog.163.com/rqivmjcr3n/blog/static/279076517201782245655/
blog.163.com/vhti96xeoa/blog/static/27906944720178224458781/
blog.163.com/vhti96xeoa/blog/static/27906944720178224455188/
blog.163.com/vhti96xeoa/blog/static/27906944720178224450791/
blog.163.com/vhti96xeoa/blog/static/27906944720178224447241/
blog.163.com/vhti96xeoa/blog/static/279069447201782235227311/
blog.163.com/vhti96xeoa/blog/static/279069447201782235221970/
blog.163.com/vhti96xeoa/blog/static/279069447201782235218678/

时间： 2024-11-08 20:57:39

使用setter方法和构造方法装配Bean的相关文章

(转)java之Spring（IOC）注解装配Bean详解

在这里我们要详细说明一下利用Annotation-注解来装配Bean. 因为如果你学会了注解,你就再也不愿意去手动配置xml文件了,下面就看看Annotation的魅力所在吧. 先来看看之前的bean注解装配例子: package com.eco.service; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import

spring 构造方法注入和setter方法注入的XML表达

1.构造方法注入 1 <?xml version="1.0" encoding="UTF-8"?> 2 <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd" > 3 <beans> 4 <bean id="person&quo

@Required 注释应用于 bean 属性的 setter 方法，它表明受影响的 bean 属性在配置时必须放在 XML 配置文件中，否则容器就会抛出一个 BeanInitializationException 异常。

@Required 注释应用于 bean 属性的 setter 方法,它表明受影响的 bean 属性在配置时必须放在 XML 配置文件中,否则容器就会抛出一个 BeanInitializationException 异常. java public class Student { private Integer age; private String name; @Required public void setAge(Integer age) { this.age = age; } public

构造方法与setter方法

上一个随笔提到了constructor-arg子标签,此随笔将会介绍一些类型的赋值方法 ①String类型.基本数据类型或其包装类都可以使用value标签属性赋值 String类型和基本类型的操作如下: //User.java文件中的代码 public User(int id){ System.out.println("序号"+ id); } public User(String name){ System.out.println("姓名" + name); } &

spring实战之装配bean

内容参考自spring in action一书. 创建应用对象之间协作关系的行为通常称为装配,这也是依赖注入的本质. 1. 创建spring配置 spring是一个基于容器的框架.如果没有配置spring,那么它就是一个空的容器,所以需要配置spring来告诉容器它需要加载哪些Bean和如何装配这些bean,这样才能确保它们能够彼此协作. 从spring3.0开始,spring容器提供了两种配置bean的方式.第一种是传统上的使用一个或多个XML文件作为配置文件.第二种提供了基于java注解的配

Spring之IOC&amp;DI/装配Bean(一)

简介 今天学习Spring的第一天,无非也就是入门基础知识.主要了解IOC和DI部分,要熟练掌握哦~ Spring简介 1. Spring介绍 Spring是一个非常活跃的开源框架:它是一个基于Core来构架多层JavaEE系统的框架,它的主要目地是简化企业开发. Spring以一种非侵入式的方式来管理你的代码,Spring提倡"最少侵入",这也就意味着你可以适当的时候安装或卸载Spring 2. Spring框架的优势 ?方便解耦,简化开发 ?Spring就是一个大工厂,可以将所有对

Spring系列之装配Bean

一.概述 容器是Spring框架的核心,Spring容器使用IOC管理所有组成应用系统的组件.Spring有两种不同的容器:BeanFactory提供最简单的容器,提供了最基础的依赖注入支持,ApplicationContext建立在BeanFactory的基础之上,提供了系统构架服务如从属性文件中读取文本信息,事件传递等. 在Spring容器中拼凑Bean叫做装配,装配Bean的时候,你是在告诉容器需要哪些Bean以及容器如何使用依赖注入将它们配合在一起. 二.装配Bean 2.1  使用XM

JAVAWEB开发之Spring详解之——Spring的入门以及IOC容器装配Bean(xml和注解的方式)、Spring整合web开发、整合Junit4测试

Spring框架学习路线 Spring的IOC Spring的AOP,AspectJ Spring的事务管理,三大框架的整合 Spring框架概述 什么是Spring? Spring是分层的JavaSE/EE full-stack(一站式)轻量级开源框架. 所谓分层: SUN提供的EE的三层结构:web层.业务层.数据访问层(也称持久层,集成层). Struts2是web层基于MVC设计模式框架. Hibernate是持久的一个ORM的框架. 所谓一站式:Spring框架有对三层的每层解决方案.

Spring学习总结之装配bean

1．  XML中显式配置 规范,文件头: <?xml version="1.0" encoding="UTF-8"?>            <beans xmlns=http://www.springframework.org/schema/beans                     xmlns=http://www.w3.org/2001/XMLSchema-instance                     xsi:schema