精华内容
下载资源
问答
  • 一、Spring jar包的导入 首先在官网下载好对应版本的jar包,我下载的是spring-framework-4.2.0.RELEASE-dist.jar版本

    一、Spring jar包的导入

    首先在官网下载好对应版本的jar包,我下载的是spring-framework-4.2.0.RELEASE-dist.jar版本,下载好之后导入对应eclipse工程中就好了,对应不同的开发内容导入对应的jar包,也可以一次性全部导入,注意一点,只需要代码源码jar就可以了,如这种

    导入之后一定要记得必须还要有一个日志包,不然会运行会报错的,如这个commons-logging-1.2-bin,一同导入即可,用eclipse编写的肯定需要提示,那就需要在装载一个对应的插件springsource-tool-suite-3.9.4.RELEASE-e4.7.3a-updatesite,我的eclipse是e4.7.3a版本的,所以用了这个,需要插件下载的可以使用如下连接http://download.springsource.com/release/TOOLS/update/3.9.4.RELEASE/e4.7/springsource-tool-suite-3.9.4.RELEASE-e4.7.3a-updatesite.zip,不同eclipse版本的可以直接改连接的版本好就好了,据说在官方已经找不到对应的老版本的插件下载了,都是改装后的eclipse工具了。

    具体装载方法如下

    1、

    2、

    3、一路next,然后同意协议

    4、安装完成后,新建一个java项目,在new中能够找到spring,安装成功

    二、spring 主要分为两大块学习,IOC和AOP学习,现在主要学习ioc

    首先新建一个java项目,在src类路径下新件一个

    容器,

    配置如下

    <?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">
    	
    	<!-- id作为这个对象的唯一标识,一个bean就是一个对象,property 是为对象的属性赋值 value是内容,value只能为基本数据类型赋值-->
    	<bean id="stu1" class="com.feilonkji.spring_2day.Student">
    		<property name="name" value="张三"></property>
    		<property name="age" value="18"></property>
    	</bean>
    	<bean id="stu2" class="com.feilonkji.spring_2day.Student">
    		<property name="name" value="李四"></property>
    		<property name="age" value="20"></property>
    	</bean>
            <bean id="stu3" class="com.feilonkji.spring_2day.Student">
    		<!-- 调用有参构造器进行创建对象并赋值,有多少个参数就有多少个constructor-arg-->
    		<constructor-arg name="name" value="王五"></constructor-arg>
    		<constructor-arg name="age" value="22"></constructor-arg>
    	</bean>
    </beans>

    代码如下

    1、学生类

    package com.feilonkji.spring_1day;
    
    /**
     * 
     * @ClassName: Student
     * @Description: 学生类,测试spring框架
     * @author zr
     * @date 2020年2月28日
     */
    public class Student {
    	String name;
    	int age;
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	@Override
    	public String toString() {
    		return "Student [name=" + name + ", age=" + age + "]";
    	}
    	
    	
    }
    

    2、测试类,利用了Junit局部测试

    package com.feilonkji.spring_1day;
    
    import org.junit.jupiter.api.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    class IOCTest {
    	/**
    	 * 从容器中拿到组件
    	 * <p>Title: test</p>
    	 * <p>Edscription: </p>
    	 */
    	@Test
    	void test() {
    		
    		//ApplicationContext :代表ioc容器
    		//ClassPathXmlApplicationContext :当前应用的配置文件在class文件的位置
    		ApplicationContext ioc = new ClassPathXmlApplicationContext("ioc.xml");
    		//通过id从容器中找到对象实例
    		Student stu = (Student)ioc.getBean("stu1");
    		System.out.println(stu);
    	}
    
    }
    

    3、有几个注意的点,在ioc容器中的配置信息,创建实例,一个bean就相当于实例化一个对象,调用的相当于实例类中的无参构造方法,为实例赋值,在实例类中一定要有setter和getter方法,ioc容器创建实例的原理是利用管理反射的机制new了一个对象,如果实例类中有有参构造方法,则可以用constructor-arg来给构造方法参数赋值,赋值一定要按参数的顺序书写。

    三、写博客没啥经验,当作复习了。

    展开全文
  • 超轻量级DI容器框架Google Guice与Spring框架的区别教程详解及其demo代码片段分享 源代码下载地址:http://www.zuidaima.com/share/1759689106541568.htm
    
    

    原文:超轻量级DI容器框架Google Guice与Spring框架的区别教程详解及其demo代码片段分享

    源代码下载地址:http://www.zuidaima.com/share/1759689106541568.htm


    依赖注入,DI(Dependency Injection),它的作用自然不必多说,提及DI容器,例如spring,picoContainer,EJB容器等等,近日,google诞生了更轻巧的DI容器……Guice!
    废话不多讲了,先看看Guice是如何实现注入的吧。
    定义一个简单的service接口和它的实现吧:

    
    package com.zuidaima.demo.guice;
    public interface MyService ... {
     void myMethod();
    }
    
    
    package com.zuidaima.demo.guice;
    
     public class MyServiceImpl implements MyService ... {
     public void myMethod() ...{
     System.out.println("Hello,World!");
     }
    }

    以上是最普通的接口和其实现,没什么可说的。
    定义一个测试类,这个类里边包括service对象的一个引用,这个对象是需要Guice进行注入的

    
    package com.zuidaima.demo.guice;
    
    import com.google.inject.Inject;
     public class Client ... {
     MyService service;
     @Inject //告诉容器,这里的service对象的引用,需要进行注入
     void setService(MyService service) ...{ //这里的方法名字可以任意定义
     this.service=service;
     }
     public void myMethod() ...{
     service.myMethod();
     }
    }
     

    这里除了加了一个@Inject,和Spring的配置没有任何的区别,@Inject,是表示对容器说,这里的service需要注射,等到运行的时候,容器会拿来一个实例给service,完成注射的过程。

    定义Guice的Module文件 告诉容器如何进行注入

    
    package com.zuidaima.demo.guice;
    
    import com.google.inject.Binder;
     import com.google.inject.Module;
     import com.google.inject.Scopes;
    
     public class MyModule implements Module ... {
     public void configure(Binder binder) ...{ binder.bind(MyService.class).to(MyServiceImpl.class).in(Scopes.SINGLETON);
     // 这句代码的意思是说:运行时动态的将MyServiceImpl对象赋给MyService定义的对象,而且这个对象是单例的。
     }
    }
     

    创建测试类

    
    package com.zuidaima.demo.guice;
    
    import com.google.inject.Guice;
    import com.google.inject.Injector;
    
     public class Test ... {
    
     public static void main(String[] args) ...{
    MyModule module=new MyModule();// 定义注射规则
    Injector injector=Guice.createInjector(module);// 根据注射规则,生成注射者
     Client client=new Client();
    injector.injectMembers(client);// 注射者将需要注射的bean,按照规则,把client这个客户端进行注射
     client.myMethod(); 
    }
    }
     

    运行测试类,控制台输出:Hello,World!
    完成注入过程

    下面看看Guice还有哪些其它的使用特性。
    1,如果在实现你确定MyService定义的对象,就要被注射为MyServiceImpl而不是其它的实现类的话,可以在MyService接口加上@ImplementedBy(MyServiceImpl.class)

    
    package com.zuidaima.demo.guice;
    
    import com.google.inject.ImplementedBy;
    
    @ImplementedBy(MyServiceImpl. class )
     // 我总觉得这样有点背离了依赖注入的初衷了 
     public interface MyService ... {
     void myMethod();
    }
     

    这样的话,在MyModule里的configure方法中就可以不加任何东西,容器就会自动注射给MyServiceImpl对象。

    2,可以对Field进行注解式注入
    在Client.java中也可以把这个@Inject标注在MyService  service;的前边,如:@Inject MyService service;


    3,可使用自定义Annotation标注。

    
    package com.zuidaima.demo.guice;
    
     import java.lang.annotation.ElementType;
     import java.lang.annotation.Retention;
     import java.lang.annotation.RetentionPolicy;
     import java.lang.annotation.Target;
    
     import com.google.inject.BindingAnnotation;
    
    @Retention(RetentionPolicy.RUNTIME)
    @Target( ... { ElementType.FIELD, ElementType.PARAMETER })
    @BindingAnnotation
     public @ interface MyInterface ... {
     
    }
     
    

    那么Client.java需要改为

     

    
    package com.zuidaima.demo.guice;
    
     import com.google.inject.Inject;
    
     public class Client ... {
    
     @Inject @MyInterface MyService service;
     
     void setService(MyService service) ...{ // 这里的方法名字可以任意定义
     this.service=service;
     }
    
     public void myMethod() ...{
     service.myMethod();
     }
    }
     

    MyModule.java中的configure方法内容需改为:

    binder.bind(MyService.class).annotatedWith(MyInterface.class).to(
        MyServiceImpl.class).in(Scopes.SINGLETON);
    意思是说对于标注为MyInterface的MyService定义的对象进行注入

    进行Annotation标注的成员(Field,method,argument等)进行自定义Annotation标注,该成员既拥有该属性,可以在运行,根据这些成员的不同属性,做一些不同的事情 例如:spring的AspectJ,xdoclet等都是如此。

    下边是我做了一下对比

    Guice与Spring的对比
      Spring Guice
    使用XML 使用将类与类之间的关系隔离到xml中,由容器负责注入被调用的对象,因此叫做依赖注入 不使用xml,将类与类之间的关系隔离到Module中,声名何处需要注入,由容器根据Module里的描述,注入被调用的对象。
    使用Annotation   使用
    支持自定义Annotation标注,对于相同的接口定义的对象引用,为它们标注上不同的自定义Annotation注释,就可以达到同一个类里边的同一个接口的引用,注射给不同的实现,在Module里用标注做区分,灵活性大大增加。
    使用Annotation也未必是好事,范型等新特性也未必是好事,目前大多的服务器均不支持jdk1.5,wls要9以前才支持,而目前的客户由于价格原因也很少选用wls9的,至少我们做过的项目中都没有。功能再强,客户不需要,何用?
    运行效率 装载spring配置文件时,需解析xml,效率低,getBean效率也不高,不过使用环境不会涉及到getBean,只有生产环境的时候会用到getBean,在装载spring应用程序的时候,已经完成全部的注射,所以这个低效率的问题不是问题。 使用Annotation,cglib, 效率高与spring最明显的一个区别,spring是在装载spring配置文件的时候把该注入的地方都注入完,而Guice呢,则是在使用的时候去注射,运行效率和灵活性高。
    类耦合度 耦合度低,强调类非侵入,以外部化的方式处理依赖关系,类里边是很干净的,在配置文件里做文章,对类的依赖性极低。 高,代码级的标注,DI标记@inject侵入代码中,耦合到了类层面上来,何止侵入,简直侵略,代码耦合了过多guice的东西,大大背离了依赖注入的初衷,对于代码的可维护性,可读性均不利
    类编写时 需要编写xml,配置Bean,配置注入 只需声明为@inject,等着被注入,
    最后在统一的Module里声明注入方式
    仅支持IOC 否,spring目前已经涉猎很多部分 是,目前仅仅是个DI容器
    是否易于代码重构 统一的xml配置入口,更改容易 配置工作是在Module里进行,和spring异曲同功
    支持多种注入方式 构造器,setter方法 Field,构造器,setter方法
    灵活性  

    1,如果同一个接口定义的引用需要注入不同的实现,就要编写不同的Module,烦琐

    2,动态注入

    如果你想注射的一个实现,你还未知呢,怎么办呢,spring是没办法,事先在配置文件里写死的,而Guice就可以做到,就是说我想注射的这个对象我还不知道注射给谁呢,是在运行时才能得到的的这个接口的实现,所以这就大大提高了依赖注射的灵活性,动态注射。

    与现有框架集成度 1, 高,众多现有优秀的框架(如struts1.x等)均提供了spring的集成入口,而且spring已经不仅仅是依赖注入,包括众多方面。
    2, Spring也提供了对Hibernate等的集成,可大大简化开发难度。
    3, 提供对于orm,rmi,webservice等等接口众多,体系庞大。
    1,可以与现有框架集成,不过仅仅依靠一个效率稍高的DI,就想取代spring的地位,有点难度。
    配置复杂度 在xml中定位类与类之间的关系,难度低 代码级定位类与类之间的关系,难度稍高

     

     再借斧子的例子说一说spring与guice的区别
    看下边对于不同社会形态下一个人(java对象,调用者)需要一把斧子(java对象,被调用者)的例子:
    (1),原始社会时,劳动社会基本没有分工,需要斧子的人(调用者)只好自己去磨一把斧子,每个人拥有自己的斧子,如果把大家的石斧改为铁斧,需要每个人都要学会磨铁斧的本领,工作效率极低。
    对应Java里的情形是:java程序里的调用者new一个被调用者的实例。类耦合度极高,修改维护烦琐,效率极低。
    (2),工业社会时,工厂出现,斧子不再由普通人完成,而由工厂生产,当人们需要斧子的时候,可以到工厂购买斧子,无需关心斧子是怎么制造出来的,如果废弃铁斧为钢斧,只需改变工厂的制造工艺即可,制作工艺是工厂决定的,工厂生产什么斧子,工人们就得用什么斧子。
     对应的Java里的情形是:Java程序的调用者可以以来简单工厂创建被调用者,变化点被隔离到了简单工厂里,虽然耦合度降低,但是调用者会和工厂耦合,而且需要定位自己的工厂。
    (3)近代工业社会,工厂蓬勃发展,人们需要什么斧子,只需要提供一个斧子图形,商家会按照你提供的图形将你的斧子订做好,送上门。
    对应Java里的情形:spring的依赖注入
    (4)进入按需要分配社会,信息进入现代化,人们不再去工厂购买斧子,不再拘泥于需要什么斧子事先画好什么样的图形,只需要打个电话,描述一下需要什么类型的斧子,或许想打造一个物美价廉的斧子,商家会根据市场零件的价格,计算出最优制作工艺,打造最适合的斧子送过来,更加信息化,更加人性化。
     对应Java里的情形:基于描述的注入,动态的,灵活简单的注入,如:Guice。
     
    对于该不该使用Guice,我想也是仁者见仁,智者见智,就象好多论坛里动不动有人会在那里讨论到底学Java还是学.net或者是使用eclipse还是Jbuilder的这类无聊话题,适合和满足项目需求的,又能省工省力简单的完成工作的,就是最好的。

    在此抛砖引玉,大家有异议的地方欢迎和我讨论。

    展开全文
  • 原创不易,转载请注明出处:超轻量级DI容器框架Google Guice与Spring框架的区别教程详解及其demo代码片段分享 代码下载地址:http://www.zuidaima.com/share/1759689106541568.htm 依赖注入,DI(Dependency ...

    原创不易,转载请注明出处:超轻量级DI容器框架Google Guice与Spring框架的区别教程详解及其demo代码片段分享

    代码下载地址:http://www.zuidaima.com/share/1759689106541568.htm

    依赖注入,DI(Dependency Injection),它的作用自然不必多说,提及DI容器,例如spring,picoContainer,EJB容器等等,近日,google诞生了更轻巧的DI容器……Guice!
    废话不多讲了,先看看Guice是如何实现注入的吧。
    定义一个简单的service接口和它的实现吧:

    package com.zuidaima.demo.guice;
    public interface MyService ... {
     void myMethod();
    }
    
    package com.zuidaima.demo.guice;
    
     public class MyServiceImpl implements MyService ... {
     public void myMethod() ...{
     System.out.println("Hello,World!");
     }
    }

    以上是最普通的接口和其实现,没什么可说的。
    定义一个测试类,这个类里边包括service对象的一个引用,这个对象是需要Guice进行注入的

    package com.zuidaima.demo.guice;
    
    import com.google.inject.Inject;
     public class Client ... {
     MyService service;
     @Inject //告诉容器,这里的service对象的引用,需要进行注入
     void setService(MyService service) ...{ //这里的方法名字可以任意定义
     this.service=service;
     }
     public void myMethod() ...{
     service.myMethod();
     }
    }
     

    这里除了加了一个@Inject,和Spring的配置没有任何的区别,@Inject,是表示对容器说,这里的service需要注射,等到运行的时候,容器会拿来一个实例给service,完成注射的过程。

    定义Guice的Module文件 告诉容器如何进行注入

    package com.zuidaima.demo.guice;
    
    import com.google.inject.Binder;
     import com.google.inject.Module;
     import com.google.inject.Scopes;
    
     public class MyModule implements Module ... {
     public void configure(Binder binder) ...{ binder.bind(MyService.class).to(MyServiceImpl.class).in(Scopes.SINGLETON);
     // 这句代码的意思是说:运行时动态的将MyServiceImpl对象赋给MyService定义的对象,而且这个对象是单例的。
     }
    }
     

    创建测试类

    package com.zuidaima.demo.guice;
    
    import com.google.inject.Guice;
    import com.google.inject.Injector;
    
     public class Test ... {
    
     public static void main(String[] args) ...{
    MyModule module=new MyModule();// 定义注射规则
    Injector injector=Guice.createInjector(module);// 根据注射规则,生成注射者
     Client client=new Client();
    injector.injectMembers(client);// 注射者将需要注射的bean,按照规则,把client这个客户端进行注射
     client.myMethod(); 
    }
    }
     

    运行测试类,控制台输出:Hello,World!
    完成注入过程

    下面看看Guice还有哪些其它的使用特性。
    1,如果在实现你确定MyService定义的对象,就要被注射为MyServiceImpl而不是其它的实现类的话,可以在MyService接口加上@ImplementedBy(MyServiceImpl.class)

    package com.zuidaima.demo.guice;
    
    import com.google.inject.ImplementedBy;
    
    @ImplementedBy(MyServiceImpl. class )
     // 我总觉得这样有点背离了依赖注入的初衷了? 
     public interface MyService ... {
     void myMethod();
    }
     

    这样的话,在MyModule里的configure方法中就可以不加任何东西,容器就会自动注射给MyServiceImpl对象。

    2,可以对Field进行注解式注入
    在Client.java中也可以把这个@Inject标注在MyService  service;的前边,如:@Inject MyService service;


    3,可使用自定义Annotation标注。

    package com.zuidaima.demo.guice;
    
     import java.lang.annotation.ElementType;
     import java.lang.annotation.Retention;
     import java.lang.annotation.RetentionPolicy;
     import java.lang.annotation.Target;
    
     import com.google.inject.BindingAnnotation;
    
    @Retention(RetentionPolicy.RUNTIME)
    @Target( ... { ElementType.FIELD, ElementType.PARAMETER })
    @BindingAnnotation
     public @ interface MyInterface ... {
     
    }
     
    

    那么Client.java需要改为

     

    package com.zuidaima.demo.guice;
    
     import com.google.inject.Inject;
    
     public class Client ... {
    
     @Inject @MyInterface MyService service;
     
     void setService(MyService service) ...{ // 这里的方法名字可以任意定义
     this.service=service;
     }
    
     public void myMethod() ...{
     service.myMethod();
     }
    }
     

    MyModule.java中的configure方法内容需改为:

    binder.bind(MyService.class).annotatedWith(MyInterface.class).to(
        MyServiceImpl.class).in(Scopes.SINGLETON);
    意思是说对于标注为MyInterface的MyService定义的对象进行注入

    进行Annotation标注的成员(Field,method,argument等)进行自定义Annotation标注,该成员既拥有该属性,可以在运行,根据这些成员的不同属性,做一些不同的事情? 例如:spring的AspectJ,xdoclet等都是如此。

    下边是我做了一下对比

    Guice与Spring的对比
      Spring Guice
    使用XML 使用将类与类之间的关系隔离到xml中,由容器负责注入被调用的对象,因此叫做依赖注入 不使用xml,将类与类之间的关系隔离到Module中,声名何处需要注入,由容器根据Module里的描述,注入被调用的对象。
    使用Annotation   使用
    支持自定义Annotation标注,对于相同的接口定义的对象引用,为它们标注上不同的自定义Annotation注释,就可以达到同一个类里边的同一个接口的引用,注射给不同的实现,在Module里用标注做区分,灵活性大大增加。
    使用Annotation也未必是好事,范型等新特性也未必是好事,目前大多的服务器均不支持jdk1.5,wls要9以前才支持,而目前的客户由于价格原因也很少选用wls9的,至少我们做过的项目中都没有。功能再强,客户不需要,何用?
    运行效率 装载spring配置文件时,需解析xml,效率低,getBean效率也不高,不过使用环境不会涉及到getBean,只有生产环境的时候会用到getBean,在装载spring应用程序的时候,已经完成全部的注射,所以这个低效率的问题不是问题。 使用Annotation,cglib, 效率高与spring最明显的一个区别,spring是在装载spring配置文件的时候把该注入的地方都注入完,而Guice呢,则是在使用的时候去注射,运行效率和灵活性高。
    类耦合度 耦合度低,强调类非侵入,以外部化的方式处理依赖关系,类里边是很干净的,在配置文件里做文章,对类的依赖性极低。 高,代码级的标注,DI标记@inject侵入代码中,耦合到了类层面上来,何止侵入,简直侵略,代码耦合了过多guice的东西,大大背离了依赖注入的初衷,对于代码的可维护性,可读性均不利
    类编写时 需要编写xml,配置Bean,配置注入 只需声明为@inject,等着被注入,
    最后在统一的Module里声明注入方式
    仅支持IOC 否,spring目前已经涉猎很多部分 是,目前仅仅是个DI容器
    是否易于代码重构 统一的xml配置入口,更改容易 配置工作是在Module里进行,和spring异曲同功
    支持多种注入方式 构造器,setter方法 Field,构造器,setter方法
    灵活性  

    1,如果同一个接口定义的引用需要注入不同的实现,就要编写不同的Module,烦琐

    2,动态注入

    如果你想注射的一个实现,你还未知呢,怎么办呢,spring是没办法,事先在配置文件里写死的,而Guice就可以做到,就是说我想注射的这个对象我还不知道注射给谁呢,是在运行时才能得到的的这个接口的实现,所以这就大大提高了依赖注射的灵活性,动态注射。

    与现有框架集成度 1, 高,众多现有优秀的框架(如struts1.x等)均提供了spring的集成入口,而且spring已经不仅仅是依赖注入,包括众多方面。
    2, Spring也提供了对Hibernate等的集成,可大大简化开发难度。
    3, 提供对于orm,rmi,webservice等等接口众多,体系庞大。
    1,可以与现有框架集成,不过仅仅依靠一个效率稍高的DI,就想取代spring的地位,有点难度。
    配置复杂度 在xml中定位类与类之间的关系,难度低 代码级定位类与类之间的关系,难度稍高

     

     再借斧子的例子说一说spring与guice的区别
    看下边对于不同社会形态下一个人(java对象,调用者)需要一把斧子(java对象,被调用者)的例子:
    (1),原始社会时,劳动社会基本没有分工,需要斧子的人(调用者)只好自己去磨一把斧子,每个人拥有自己的斧子,如果把大家的石斧改为铁斧,需要每个人都要学会磨铁斧的本领,工作效率极低。
    对应Java里的情形是:java程序里的调用者new一个被调用者的实例。类耦合度极高,修改维护烦琐,效率极低。
    (2),工业社会时,工厂出现,斧子不再由普通人完成,而由工厂生产,当人们需要斧子的时候,可以到工厂购买斧子,无需关心斧子是怎么制造出来的,如果废弃铁斧为钢斧,只需改变工厂的制造工艺即可,制作工艺是工厂决定的,工厂生产什么斧子,工人们就得用什么斧子。
     对应的Java里的情形是:Java程序的调用者可以以来简单工厂创建被调用者,变化点被隔离到了简单工厂里,虽然耦合度降低,但是调用者会和工厂耦合,而且需要定位自己的工厂。
    (3)近代工业社会,工厂蓬勃发展,人们需要什么斧子,只需要提供一个斧子图形,商家会按照你提供的图形将你的斧子订做好,送上门。
    对应Java里的情形:spring的依赖注入
    (4)进入按需要分配社会,信息进入现代化,人们不再去工厂购买斧子,不再拘泥于需要什么斧子事先画好什么样的图形,只需要打个电话,描述一下需要什么类型的斧子,或许想打造一个物美价廉的斧子,商家会根据市场零件的价格,计算出最优制作工艺,打造最适合的斧子送过来,更加信息化,更加人性化。
     对应Java里的情形:基于描述的注入,动态的,灵活简单的注入,如:Guice。
     
    对于该不该使用Guice,我想也是仁者见仁,智者见智,就象好多论坛里动不动有人会在那里讨论到底学Java还是学.net或者是使用eclipse还是Jbuilder的这类无聊话题,适合和满足项目需求的,又能省工省力简单的完成工作的,就是最好的。

    在此抛砖引玉,大家有异议的地方欢迎和我讨论。

    展开全文
  • 框架容器部分终于调通了!容器实在太重要了,所以有用了一个名词叫“核心容器”。 容器为什么那么重要呢?这个有必要好好说道说道。 1、首先我们从框架名称面向接口编程说起,什么是面向接口编程?(这个度娘回答...

    新框架的容器部分终于调通了!容器实在太重要了,所以有用了一个名词叫“核心容器”。

    容器为什么那么重要呢?这个有必要好好说道说道。

    1、首先我们从框架名称面向接口编程说起,什么是面向接口编程?(这个度娘回答一下)

          解读一下:类是个体的定义(建模), 个体的每一方面都可以是一个接口

          说白点,其一接口可以代表对象(类)一个方面,再说透点对象可能是多面手(继承多个接口),能在不同场景(作为不同接口的实例)下正常工作

          其二每个接口可以有不同实现,只要实现了这个接口,基本上就可以替换这个位置来正常工作

    2、我觉得面向接口编程本质上还是面向对象编程,只是抽象层次更高,更便于扩展和替换

         我们需要很多很多的对象来支撑系统的功能需要和扩展需求,还需要每个位置上的对象方便“随时”替换,扩充

         那我们怎么来管理这个庞大的对象库呢,如何方便的编排以便管理?这里就要说到容器了,容器可以很好的胜任这个工作。

    3、容器的作用

      我认为容器就是仓库,就是柜子,就是盒子,以便我们可以按自己喜欢的方式存放自己的对象,以便需要的时候能方便的找到他们

          好的容器还能维护对象的创建、生命周期、控制反转(IOC)、依赖注入(DI)、拦截方法执行(AOP)等


    前面废话太多,老规矩先上例子

    一、对象的创建和管理由容器负责

    1、以下还是前面那篇上下文的例子,使用容器来简化后的代码

     以上代码是不是简单漂亮多了

     2、代码虽然简单了,功能一点都没有水分哦,看看以下执行结果截图

    是不是结果上一篇的完全一样啊。

    3、结果一样不算什么,改个配置(不改代码),看看结果

    4、再改配置(还是不该代码)

    这次生动了吧,一家人各有各的个性了,是不是很炫啊。

    5、大家看看配置

    明眼人一眼就能看出这个是Unity容器的配置;有人说,你不是不要依赖Unity容器吗?我发誓确实没有依赖Unity容器,但我也没说不用Unity啊。我只是要做一个框架,其他技术方案都可以集成进来,容器也是。

    你熟悉Unity就用Unity,你熟悉Spring.net也可以放心使用,只要你封装一下并继承这个框架的容器接口,再注册进来就可以正常工作了

     

    二、使用了Unity容器,但不依赖Unity容器

    1、调用容器的地方没有依赖Unity

    这个测试项目除了系统的几个引用,就只引用了这个主框架了

    2、主框架没有引用Unity容器

    没骗你们吧?真没依赖Unity,主框架甚至除了几个简单的系统引用,没有依赖(引用)任何第三方组件,但是这一点都不影响我使用大量第三方的库,因为这里是"面向接口可扩展框架"

    是不是现在又对接口有了进一步的理解了,是不是“面向接口可扩展框架”这个名字有点名符其实味道了。

     

    三、下面来解密他到底怎么运行的

    1、看入口,看应用程序(这里是控制台程序)的引用

    哈哈,是不是找到了,终于看到Unity引用了

    但是不要被表象所迷惑,其实这里的主角是Fang.Unity,因为这个项目可以不直接引用Unity容器,Fang.Unity是对Unity容器的封装。

    控制台程序对Unity相关dll是运行时依赖,并不是编译依赖,这里直接引用上是为了便于调试

    2、继续探究原理

    Fang.Unity总不会是自动运行的吧?当然不是,上代码

    上图有一句不起眼,但是非常重要的一行代码“Fang.Unity.ContainerFactory.Init()”,他就是“罪魁祸首”了

    换句话话说,Unity容器是完全作为插件在本框架中运行的,如果我不调用Unity的Init,调用Spring.net的Init,那当前所有地方调用的就都是Spring.net容器了。

    有人说这也太不方便了吧,当然不是每次使用容器都要调用,如果是web项目可以在global的Application_Start中调用一下就Ok了,也可以在HttpModule的Init中调用也可以。

    大部分时候我们在开发中大量使用容器,但并不用想我具体用什么容器。

    换句话说,我熟悉Unity容器,我使用Unity容器配置调试通过的组件给你使用,但是你一直都用Spring.net(或者其他容器),你调用Spring.net容器的封装,把配置修改为Spring.net的配置,代码一样能正常运行

    注:前提是组件开发的时候使用的是框架的容器支持,没有直接引用Unity容器和直接调用Unity容器的代码

    3、还是看一眼Fang.Unity.ContainerFactory.Init是什么鬼吧(哈哈,要不睡不着了)

    Unity容器就不在这里展开,我会单开一篇讲Unity容器和Unity封装等

     

    四、核心容器解析

    1、容器相关实现类截图

    2、核心类图如下:

    稍作解析各个类的分工:

         A:IContainer接口是定义容器需要的基本功能

         B:IContainerFactory定义容器工厂接口

         C:GlobalContainer是个静态配置类,提供注册外部容器组件功能及提供调用容器的Api

    这个是实现容器插件化的关键,这个实现是参考了Asp.net Mvc的DependencyResolver

       D:SimpleContainer提供一个简单和默认的容器和容器工厂实现

      AppContext中的上线文容器就是他实现的,如果不配置扩展容器功能,使用的容器就是他了,但是他其实就是一个字典缓存,存个东西,取个东西,完全没有问题,复杂配置及DI等就没戏了

       E:ContainerWrapper是个容器封装拦截类,拦截容器的操作,以便增加特性和功能

           这个以后再展开讲,里面有一个很有意思的特性

       F:ContainerFactoryCacheWrapper是容器工厂封装及缓存

           也就是外面实现的容器工厂是不用考虑单例模式缓存什么的,他给包办了,而且把每个生产好的容器对象检查和打包好

     

    五、多容器的应用

    1、我们需要多个容器来编排众多对象

    就好比我从超市一次性买回来很多东西,有鸡蛋、排骨、蔬菜、儿童玩具、衣服等等。我不能弄一个大箱子全部放进去,也不乱放,不能把衣服和排骨一起放冰箱(会被媳妇骂死的)。排骨进冰箱冷冻室,鸡蛋和蔬菜进冰箱冷藏室。儿童玩具放儿童床。衣服放衣柜。

    代码做了微调,再看运行结果

     有人说,你怎么越改越复杂啊,代码复杂一点点,但是配置更加有条理有的时候是值得的,看配置

    这只是一个简单拆分容器的方案,也可以按对象图谱来划分容器,这样更加合理,因为对象之间有相互的依赖关系,使用容器来做控制反转也就是这个意思

    如果是支持子容器的容器工具(Unity就支持),一个系统就可以按树状划分容器,整个系统的公共配置是根容器,每个子系统都有各自的容器配置,每个子系统的各个模块也有自己的容器配置,子容器可以继承父容器也可以覆盖父容器的配置

    2、下面做一个树状子容器的例子

    这个效果是不是杠杠的,代码也是漂亮的一塌糊涂,是怎么配置的,也看一下吧

    总结一下,容器名是优美的链式语法,配置文件是树状管理结构,Perfect!!!

     

    六、容器扩展

    1、SimpleContainer容器不"Simple"

    前面有介绍IContainer接口,细心看一下就会发现有添加(Regist)和读取(Resolve)方法,但是没有删除对象的方法,我们要删除怎么办

    但是SimpleContainer可是有Remove方法,使用框架的容器功能就要放弃自己更加强大的容器功能是不是有点遗憾,可不可以鱼和熊掌兼得?当然可以,上下文那个就是用SimpleContainer实现的,作用域结束就从容器中删除对象。

    我们这里再举一个简单的例子演示一下

    使用完整的框架容器支持还是可以使用自定义容器的更多功能技巧就是IContainer接口有一个Provider属性用来对外暴露原容器对象的Provider属性,只要把自己想扩展暴露的扩展功能放在Provider属性中即可

    当然也可以和SimpleContainer定义Provider一样,直接返回容器本身

    细心的用户可能注意到这个例子里面出现一个新的东西(Fang.Framework.Factory.Create),这个和前面的GlobalContainer.Factory.Create效果是一样的,Fang.Framework.Factory是个静态类,负责把框架的主要工厂方法都汇总起来,以便查找和使用。

    注:这个例子是使用SimpleContainer的运行这个测试例子的时候要把代码"Fang.Unity.ContainerFactory.Init()"注释掉

    但是还是要特别强调一下,这种扩展方式虽然简单,但是并不推荐使用

    因为你一旦对Provider强制类型转化的时候你就依赖特定的容器实现了,这样这些的代码就可能不能适应其他容器,也就是说你的代码强依赖特定的容器,这样就违背了本框架的精神。

    一句话,你需要更多的特性就会牺牲一些通用性,如果每段代码都是特例,不能扩展,那这个系统就该有麻烦了。

     

    2、使用ContainerWrapper的扩展

    2.1 前面有提到ContainerWrapper时用来包装容器的,通过框架产生的容器(IContainer)对象都是被ContainerWrapper包装过的,而且ContainerWrapper拦截IContainer所有的方法

    只要定义一个容器包装类继承ContainerWrapper,重写自己想要扩展的功能,定义一个ContainerFactory类(继承IContainerFactory)返回的包装后的容器对象,框架里面有调用一个CheckWrapper方法处理新产生的容器对象,如果对象可以转化为ContainerWrapper对象就不需要再次包装了

    2.2 还有一个扩展技巧就是先按没有扩展的方式注册容器工厂

    然后对容器工厂再次扩展返回ContainerWrapper对象,也就是自己定义容器封装功能代替框架默认的封装逻辑

    以后可能会开发一个通用DI标注扩展功能,就打算使用这种方式,获取对象的时候检查当前对象或者类型是否有对应标注(Attribute),如果有就调用特殊逻辑处理,没有统一的DI标注,使用DI就不得不依赖特定容器,这样就会影响代码复用性和可迁移性。

     

    七、容器"黑科技"

    1、快速检索

    用黑科技来改造树状结构的例子

    可以配置很多容器来管理对象,但调用我们却不用直接和每个容器打交道,只要按一定规则命名,可以使用任一个容器对象来调取任一个对象配置

    如果以上黑科技再配合上DI,那就更Perfect了!!!

    注:这里面有一个插曲,一个工程师使用容器配置DI,他指着一个配置文件里面的一个节点对我说,我想要把这个节点DI到我的Controller上。我对他解释,"DI不能这样的,你必须把这个节点放在根容器中,或者定义一个分区并指向一个容器,然后把这个节点复制到那个新容器中"。这个工程师听得满头雾水,迷茫的说"我只是想把这个节点映射到我的Controller上,...";有了这个黑科技,我可以放心告诉他,你写一个DI标注就可以了

     2、上下文容器的快速检索

    上下文是通过容器实现的,是否可以统一检索呢?答案是肯定的,以上例子就是

    上下文容器检索提供了一个特殊的名字"$"(这个名字有点俗,我没想到更好的,谁又更好的建议一下),使用“$.name”从上下文中检索,理论上讲,上下文容器的值也应该可以支持DI,当然DI的时间应该在上下文容器值产生之后

     

    就写这么多了,还有很多东西要写,也有很多功能待开发,以后再补充吧。

    提供测试源代码下载

    特别强调,本框架还在开发中,并没有进行完全测试,不排除有重大bug的可能性,切忌暂时不要拿到自己现实项目中,出现问题后果自负,而且本框架还没有正式开源,没有开源授权。

    转载于:https://www.cnblogs.com/xiangji/p/5423613.html

    展开全文
  • 首先yum install docker 安装dockerservicedockerstart 启动dockerdockerpulldocker.io/skiychan/nginx-php 下载这个镜像dockerimages 查看镜像然后创建容器docker run --name "wzj" -p 8086:80 -p 9100:9100 -p ...
  • 一个IoC容器+Web层框架+ORM框架的简单实现(适用于学习用) 类似于SSH实现。     在学习期间写的,实现相对简单。欢迎下载。   涉及技术点:  反射、注解、配置文件、动态代理 实现了:  IoC AOP Web层...
  • docker容器composer 部署 laravel框架

    千次阅读 2019-04-23 11:45:00
    首先yum install docker 安装docker servicedockerstart 启动docker dockerpull docker.io/skiychan/nginx-php 下载这个镜像 ...然后创建容器 docker run --name "wzj" -p 8086:80 ...
  • 首先下载下载下来,包括三个部分:一个fonts文件夹 一个css文件 + 一个js文件 bootstrap 应用: <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <!-- meta:vp ...
  • HelloWorld;...HelloWorld项目构建(一般框架的写法) 1 用idea创建Spring的工程 工程创建好后会自动由maven下载需要的jar包 核心容器 spring-beans-4.0.0.RELEASE.jar spring-context-4.0.0.RELEAS...
  • 声明,以下案例使用的JDK9,Spring-framework-5.0.9.RELEASE; 使用的依赖、约束、文档,这三个必须下载,解压后如下;...整个spring框架的结构如下【该图是spring官网给出的】: ​​​​​​Sp...
  • Unity这是.net下非常流行的实现ioc与di的框架 引用 直接nuget搜索 这三个包,直接引用下载 ui层 private void Form1_Load(object sender, EventArgs e) { IUnityContainer container = new UnityContainer(); ....
  •  依赖注入框架Autofac的简单使用 ... Autofac是一款IOC框架,比较于其他的IOC框架,如Spring.NET,...下载地址:http://code.google.com/p/autofac/downloads/list   1)解压它的压缩包,主要看到Autof
  • 5 spring容器内部使用拦截器,以Spring AOP的方式实现事务控制管理。 系统实体对象: 图书类型:图书类别,类别名称,可借阅天数 图书:图书条形码,图书名称,图书所在类别,图书价格,库存,出版社,图书图片 ...
  • Spring框架是轻量级的开源的JavaEE框架 2>Spring框架是由于软件开发的复杂性而创建的 3>Spring框架的两个核心部分:IOC和AOP IOC:控制反转,把创建对象的过程交给Spring进行管理 AOP:面向切面,不修改源代码...
  • .NET领域最为流行的IOC框架之一Autofac 一、前言 Autofac是.NET领域最为流行的IOC框架之一,微软的Orchad开源程序使用的就是Autofac,Nopcommerce开源程序也是用的Autofac。...建议下载Orchad和...
  • php容器

    2019-09-28 11:20:09
    项目地址 ...下载在本地 执行 index.php 效果 $app = new Application(); $app->db->test(); 一般框架都有容器这个概念,当基础类多了,会很零散,所以得有一个东西能收纳...
  • Spring容器

    2018-06-28 21:33:00
    1.Spring简介: a)Spring春天 ... c)设计理念:轮子理念,不要重复创造轮子;...d)Spring可以被理解为一个容器,用于管理其他的框架; e)Spring个版本下载地址:https://repo.spring.io/webapp/#/artifacts/brow...
  • 框架基础

    2019-09-27 21:04:19
    框架基础-01MavenSpring IoC容器1 概述1.1 依赖反转模式1.2 IOC中的注入方式2. IOC容器的设计与实现:BeabFactory和ApplicationContexthtml中的基础结构配置核心的xml在这里插入图片描述Lombok Maven 1、Maven的下载...
  • 在工作开发时,因为某些项目需要分布式的框架或者一些集群,由于开发与op沟通成本和时间问题,常常无法快速得到一个开发可用的测试环境,那么就需要程序员在自己的测试机上安装一些集群和工具,但是由于测试机只有一...
  • 作为流行的容器管理技术,Docker的最大优点是能将应用与计算环境分离,允许开发者在同一台计算机上使用不同的技术。通过Docker,开发者可以使应用程序在同一服务器上运行Python、Ruby、PHP、Node JS或任何其他语言,...
  • spring框架

    2020-03-30 16:42:08
    spring框架 1、spring的核心是控制反转(IoC)和面向切面(AOP) 2、tx代表事务管理 3、核心容器(beans core context expression)4个核心+1个依赖(Commons-logins jar) 4、maven下载,缺啥jar包就自动下载的 5、...
  • ubuntu64位 18.04(开发使用桌面版本) Nginx ... 开发工具:PHPStorm 其他技术栈:laravel、VUE、NodeJs...https://laravelacademy.org/laravel-docs-5_5 框架文档 https://learnku.com/docs/laravel/5.5/deployme...
  • 搞懂 php 容器容器实践DEMO

    千次阅读 2019-12-04 17:36:30
    项目地址 ...下载在本地 执行 index.php 效果 $app = new Application(); $app->db->test(); 一般框架都有容器这个概念,当基础类多了,会很零散,所以得有一个东西能收纳这些功能...
  • @Bean给容器中注册组件.avi 04、组件注册-自定义TypeFilter指定过滤规则.avi 06、组件注册-@Lazy-bean懒加载.avi 08、组件注册-@Import-给容器中快速导入一个组件.avi 10、组件注册-@Import-使用...
  • 下载地址:https://v3.bootcss.com/,下载Bootstrap3版本 下载之后把文件中不需要的文件都删掉 需要获取的样式代码,可以直接从这些地方找到,...二、布局容器 Bootstrap需要为页面内容和栅格系统包裹一个.cont...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 769
精华内容 307
关键字:

容器框架下载