169it科技资讯


当前位置:  编程技术>软件工程/软件设计
本页文章导读:
    ▪使用最多的9种License      BSD类型:推荐使用,商业友好型许可证 Apache V2.0 --  ACE, Tomcat 允许各种链接,无开源义务允许修改,无开源义务软件所有人授予专利许可 BSD -- SVN MIT -- ASN.1 允许各种链接,无开源义务.........
    ▪设计模式之五S:动态代理模式(Dynamic Proxy Pattern)              代理模式的作用是:为其他对象提供一种代理以控制对这个对象的访问。在某些情况下,一个客户不想或者不能直接引用另一个对象,而代理对象可以在客户端和目标.........
    ▪大话设计模式——简单工厂模式       简单工厂模式解释:         简单工厂模式(Simple Factory Pattern)属于类的创新型模式,又叫静态工厂方法模式(Static FactoryMethod Pattern),是通过专门定义一个类来负.........

[1]使用最多的9种License
    来源: 互联网  发布时间: 2013-11-19
BSD类型:推荐使用,商业友好型许可证
Apache V2.0 --  ACE, Tomcat
  • 允许各种链接,无开源义务
  • 允许修改,无开源义务
  • 软件所有人授予专利许可


  • BSD -- SVN MIT -- ASN.1
  • 允许各种链接,无开源义务
  • 允许修改,无开源义务
  • 无专利规定


  • MPL类:可以使用,但关注修改后对应的开源义务
    CPL V1.0   -- JUnit EPL V1.0   -- Eclipse MPL V1.0   -- FireFox
    CDDL V1.0  -- OpenSolaris
  • 允许各种链接,无开源义务
  • 允许修改,但修改部分需要开源
  • 软件所有人授予专利许可


  • GPL类:谨慎使用,只允许动态链接方式使用
    LGPL V2  -- Jboss OpenOffice UcLibc SDL
  • 允许各种链接,但除动态链接外其他形式被链接的整个产品需要开源
  • 允许修改,但要求被修改部分及整个产品均需要开源。实践中可采取的规避措施是,将修改后的软件先以LGPL开源出去,再动态链接回来,以避免产品整体开源。
  • 仅原则性声明专利应免费许可,无详细规定。

  • GPL V2  -- Linux 
  • 允许各种链接,但被链接的整个产品需要开源
  • 允许修改,但被修改部分及整个产品均需要开源
  • 仅原则性声明专利应免费许可,无详细规定
  • 注释:谨慎使用,由于可能导致产品整体负有开源义务,不建议使用


    作者:lida2003 发表于2013-4-27 15:33:46 原文链接
    阅读:38 评论:0 查看评论

        
    [2]设计模式之五S:动态代理模式(Dynamic Proxy Pattern)
        来源: 互联网  发布时间: 2013-11-19

           代理模式的作用是:为其他对象提供一种代理以控制对这个对象的访问。在某些情况下,一个客户不想或者不能直接引用另一个对象,而代理对象可以在客户端和目标对象之间起到中介的作用。   抽象角色:声明真实对象和代理对象的共同接口;
    代理角色:代理对象角色内部含有对真实对象的引用,从而可以操作真实对象,同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同时,代理对象可以在执行真实对象操作时,附加其他的操作,相当于对真实对象进行封装。
    真实角色:代理角色所代表的真实对象,是我们最终要引用的对象。
    按照代理的创建时期,代理类可以分为两种。 
    静态代理:由程序员创建或特定工具自动生成源代码,再对其编译。在程序运行前,代理类的.class文件就已经存在了。 
    动态代理:在程序运行时,运用反射机制动态创建而成。 
    首先看一下静态代理: 
    1、Count.java 

    package net.battier.dao;  

    /** 
     * 定义一个账户接口 
     */  
    public interface Count {  
        // 查看账户方法  
        public void queryCount();  
        // 修改账户方法  
        public void updateCount();  
    }  
    2、CountImpl.java 

    package net.battier.dao.impl;  
      
    import net.battier.dao.Count;  
    /** 
     * 委托类(包含业务逻辑) 
     */  
    public class CountImpl implements Count {  
        @Override  
        public void queryCount() {  
            System.out.println("查看账户方法...");  
        }  
        @Override  
        public void updateCount() {  
            System.out.println("修改账户方法...");  
        }  
    }  
      
    CountProxy.java  
    package net.battier.dao.impl;  
      
    import net.battier.dao.Count;  
      
    /** 
     * 这是一个代理类(增强CountImpl实现类) 
     */  
    public class CountProxy implements Count {  
        private CountImpl countImpl;   
        /** 
         * 覆盖默认构造器 
         */  
        public CountProxy(CountImpl countImpl) {  
            this.countImpl = countImpl;  
        }  
        @Override  
        public void queryCount() {  
            System.out.println("事务处理之前");  
            // 调用委托类的方法;  
            countImpl.queryCount();  
            System.out.println("事务处理之后");  
        }  
        @Override  
        public void updateCount() {  
            System.out.println("事务处理之前");  
            // 调用委托类的方法;  
            countImpl.updateCount();  
            System.out.println("事务处理之后");  
        }  
    }  
    3、TestCount.java 

    package net.battier.test;  
      
    import net.battier.dao.impl.CountImpl;  
    import net.battier.dao.impl.CountProxy;  
    /** 
     *测试Count类 
     */  
    public class TestCount {  
        public static void main(String[] args) {  
            CountImpl countImpl = new CountImpl();  
            CountProxy countProxy = new CountProxy(countImpl);  
            countProxy.updateCount();  
            countProxy.queryCount();  
        }  
    }  
    观察代码可以发现每一个代理类只能为一个接口服务,这样一来程序开发中必然会产生过多的代理,而且,所有的代理操作除了调用的方法不一样之外,其他的操作都一样,则此时肯定是重复代码。解决这一问题最好的做法是可以通过一个代理类完成全部的代理功能,那么此时就必须使用动态代理完成。 
    再来看一下动态代理: 
    JDK动态代理中包含一个类和一个接口: 
    InvocationHandler接口: 
    public interface InvocationHandler { 
         public Object invoke(Object proxy,Method method,Object[] args) throws Throwable; 

    参数说明: 
    Object proxy:指被代理的对象。 
    Method method:要调用的方法 
    Object[] args:方法调用时所需要的参数 

    可以将InvocationHandler接口的子类想象成一个代理的最终操作类,替换掉ProxySubject。 

    Proxy类: 
    Proxy类是专门完成代理的操作类,可以通过此类为一个或多个接口动态地生成实现类,此类提供了如下的操作方法: 
    public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, 
    InvocationHandler h) 
                                   throws IllegalArgumentException 
    参数说明: 
    ClassLoader loader:类加载器 
    Class<?>[] interfaces:得到全部的接口 
    InvocationHandler h:得到InvocationHandler接口的子类实例 

    Ps:类加载器 
    在Proxy类中的newProxyInstance()方法中需要一个ClassLoader类的实例,ClassLoader实际上对应的是类加载器,在Java中主要有一下三种类加载器; 
    Booststrap ClassLoader:此加载器采用C++编写,一般开发中是看不到的; 
    Extendsion ClassLoader:用来进行扩展类的加载,一般对应的是jre\lib\ext目录中的类; 
    AppClassLoader:(默认)加载classpath指定的类,是最常使用的是一种加载器。 

    动态代理 
    与静态代理类对照的是动态代理类,动态代理类的字节码在程序运行时由Java反射机制动态生成,无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作,而且提高了软件系统的可扩展性,因为Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。 

    动态代理示例: 
    1、BookFacade.java 

    package net.battier.dao;  
      
    public interface BookFacade {  
        public void addBook();  
    }  
    package net.battier.dao.impl;  
      
    import net.bat
        
    [3]大话设计模式——简单工厂模式
        来源: 互联网  发布时间: 2013-11-19

    简单工厂模式解释: 

           简单工厂模式(Simple Factory Pattern)属于类的创新型模式,又叫静态工厂方法模式(Static FactoryMethod Pattern),是通过专门定义一个类来负责创建其他类的实例,被创建的实例通常都具有共同的父类。

    简单工厂模式的UML图: 

           简单工厂模式中包含的角色及其相应的职责如下:

           工厂角色(Creator):这是简单工厂模式的核心,由它负责创建所有的类的内部逻辑。当然工厂类必须能够被外界调用,创建所需要的产品对象。

           抽象(Product)产品角色:简单工厂模式所创建的所有对象的父类,注意,这里的父类可以是接口也可以是抽象类,它负责描述所有实例所共有的公共接口。

           具体产品(Concrete Product)角色:简单工厂所创建的具体实例对象,这些具体的产品往往都拥有共同的父类。

    简单工厂模式深入分析:

           简单工厂模式解决的问题是如何去实例化一个合适的对象。

           简单工厂模式的核心思想就是:有一个专门的类来负责创建实例的过程。

           具体来说,把产品看着是一系列的类的集合,这些类是由某个抽象类或者接口派生出来的一个对象树。而工厂类用来产生一个合适的对象来满足客户的要求。

           如果简单工厂模式所涉及到的具体产品之间没有共同的逻辑,那么我们就可以使用接口来扮演抽象产品的角色;如果具体产品之间有功能的逻辑或,我们就必须把这些共同的东西提取出来,放在一个抽象类中,然后让具体产品继承抽象类。为实现更好复用的目的,共同的东西总是应该抽象出来的。

           在实际的的使用中,抽闲产品和具体产品之间往往是多层次的产品结构,如下图所示:

    下面以运算器的设计例子,该例子用的模板实现:

    抽象产品:运算类

    #ifndef OPERATION_H
    #define OPERATION_H
    template <class T>
    class Operation
    {
    public:
    	virtual T computeOpreration() = 0;
    	void setNumA(T _numA);
    	void setNumB(T _numB);
    	T getNumA();
    	T getNumB();
    private:
    	T numA;
    	T numB;
    };
    
    template<class T>
    void Operation<T>::setNumA(T _numA)
    {
    	numA = _numA;
    }
    
    template<class T>
    void Operation<T>::setNumB(T _numB)
    {
    	numB = _numB;
    }
    
    template<class T>
    T Operation<T>::getNumA()
    {
    	return numA;
    }
    
    template<class T>
    T Operation<T>::getNumB()
    {
    	return numB;
    }
    #endif

    具体产品:加法类

    #include"Operation.h"
    #ifndef OPERATIONADD_H
    #define OPERATIONADD_H
    template<class T>
    class OperationAdd : public Operation<T>
    {
    public:
    	T computeOpreration();
    };
    
    template<class T>
    T OperationAdd<T>::computeOpreration()
    {
    	return (getNumA() + getNumB());
    }
    #endif
    

    具体产品:乘法类

    #include"Operation.h"
    #ifndef OPERATIONMUL_H
    #define OPERATIONMUL_H
    template<class T>
    class OperationMul : public Operation<T>
    {
    public:
    	T computeOpreration();
    };
    
    template<class T>
    T OperationMul<T>::computeOpreration()
    {
    	return (getNumA() * getNumB());
    }
    #endif OPERATIONMUL_H

    具体产品:减法类

    #include"Operation.h"
    #ifndef OPERATIONSUB_H
    #define OPERATIONSUB_H
    template<class T>
    class OperationSub : public Operation<T>
    {
    public:
    	T computeOpreration();
    };
    
    template<class T>
    T OperationSub<T>::computeOpreration()
    {
    	return (getNumA() - getNumB());
    }
    #endif

    具体产品:除法类

    #include"Operation.h"
    #ifndef OPERATIONDIV_H
    #define OPERATIONDIV_H
    template<class T>
    class OperationDiv : public Operation<T>
    {
    public:
    	T computeOpreration();
    };
    
    template<class T>
    T OperationDiv<T>::computeOpreration()
    {
    	return (getNumA() / getNumB());
    }
    #endif

    抽象工厂类:计算工厂类

    #include"Operation.h"
    #include"OperationSub.h"
    #include"OperationAdd.h"
    #include"OperationMul.h"
    #include"OpertaionDiv.h"
    
    #ifndef OPERATIONFACTORY_H
    #define OPERATIONFACTORY_H
    template<class T>
    class OperationFactory
    {
    public:
    	Operation<T>* createOperation(char operate);
    };
    
    template<class T>
    Operation<T>* OperationFactory<T>::createOperation(char operate)
    {
    	Operation<T> *oper = NULL;
    	switch(operate)
    	{
    	case '+':
    		oper = new OperationAdd<T>();break;
    	case '-':
    		oper = new OperationSub<T>();break;
    	case '*':
    		oper = new OperationMul<T>();break;
    	case '/':
    		oper = new OperationDiv<T>();break;
    	}
    	return oper;
    }
    #endif

    简单的main函数调用:

    #include<iostream>
    #include"OperationFactory.h"
    using namespace std;
    
    int main()
    {
    	
    	OperationFactory<double> fac;
    	Operation<double> *per = fac.createOperation('+');
    	per->setNumA(10.0);
    	per->setNumB(2.0);
    	cout<<"the result of Add is : "<<per->computeOpreration()<<endl;
    	return 0;
    }

    今天碰到主要问题还是模板的编写,以前觉得挺简单的,一直没去写,写了才发现要注意很多,尤其是编译这一块,这是今天的成果。速度跑起来。

    作者:yujiaming493323 发表于2013-4-27 16:31:59 原文链接
    阅读:59 评论:0 查看评论

        
    最新技术文章:
    ▪主-主数据库系统架构    ▪java.lang.UnsupportedClassVersionError: Bad version number i...    ▪eclipse项目出现红色叉叉解决方案
    ▪Play!framework 项目部署到Tomcat    ▪dedecms如何做中英文网站?    ▪Spring Batch Framework– introduction chapter(上)
    ▪第三章 AOP 基于@AspectJ的AOP    ▪基于插件的服务集成方式    ▪Online Coding开发模式 (通过在线配置实现一个表...
    ▪观察者模式(Observer)    ▪工厂模式 - 程序实现(java)    ▪几种web并行化编程实现
    ▪机器学习理论与实战(二)决策树    ▪Hibernate(四)——全面解析一对多关联映射    ▪我所理解的设计模式(C++实现)——解释器模...
    ▪利用规则引擎打造轻量级的面向服务编程模式...    ▪google blink的设计计划: Out-of-Progress iframes    ▪FS SIP呼叫的消息线程和状态机线程
    ▪XML FREESWITCH APPLICATION 实现    ▪Drupal 实战    ▪Blink: Chromium的新渲染引擎
    ▪(十四)桥接模式详解(都市异能版)    ▪你不知道的Eclipse用法:使用Allocation tracker跟...    ▪Linux内核-进程
    ▪你不知道的Eclipse用法:使用Metrics 测量复杂度    ▪IT行业为什么没有进度    ▪Exchange Server 2010/2013三种不同的故障转移
    ▪第二章 IoC Spring自动扫描和管理Bean    ▪CMMI简介    ▪目标检测(Object Detection)原理与实现(六)
    ▪值班总结(1)——探讨sql语句的执行机制    ▪第二章 IoC Annotation注入    ▪CentOS 6.4下安装Vagrant
    ▪Java NIO框架Netty1简单发送接受    ▪漫画研发之八:会吃的孩子有奶吃    ▪比较ASP和ASP.NET
    ▪SPRING中的CONTEXTLOADERLISTENER    ▪在Nginx下对网站进行密码保护    ▪Hibernate从入门到精通(五)一对一单向关联映...
    ▪.NET领域驱动设计—初尝(三:穿过迷雾走向光...    ▪linux下的块设备驱动(一)    ▪Modem项目工作总结
    ▪工作流--JBPM简介及开发环境搭建    ▪工作流--JBPM核心服务及表结构    ▪Eclipse:使用JDepend 进行依赖项检查
    ▪windows下用putty上传文件到远程Linux方法    ▪iBatis和Hibernate的5点区别    ▪基于学习的Indexing算法
    ▪设计模式11---设计模式之中介者模式(Mediator...    ▪带你走进EJB--JMS编程模型    ▪从抽象谈起(二):观察者模式与回调
    ▪设计模式09---设计模式之生成器模式(Builder)也...    ▪svn_resin_持续优化中    ▪Bitmap recycle方法与制作Bitmap的内存缓存
    ▪Hibernate从入门到精通(四)基本映射    ▪设计模式10---设计模式之原型模式(Prototype)    ▪Dreamer 3.0 支持json、xml、文件上传
    ▪Eclipse:使用PMD预先检测错误    ▪Jspx.net Framework 5.1 发布    ▪从抽象谈起(一):工厂模式与策略模式
    ▪Eclipse:使用CheckStyle实施编码标准    ▪【论文阅读】《Chain Replication for Supporting High T...    ▪Struts2 Path_路径问题
    ▪spring 配置文件详解    ▪Struts2第一个工程helloStruts极其基本配置    ▪Python学习入门基础教程(learning Python)--2 Python简...
    ▪maven springmvc环境配置    ▪基于SCRUM的金融软件开发项目    ▪software quality assurance 常见问题收录
    ▪Redis集群明细文档    ▪Dreamer 框架 比Struts2 更加灵活    ▪Maven POM入门
    ▪git 分支篇-----不断更新中    ▪Oracle非主键自增长    ▪php设计模式——UML类图
    ▪Matlab,Visio等生成的图片的字体嵌入问题解决...    ▪用Darwin和live555实现的直播框架    ▪学习ORM框架—hibernate(二):由hibernate接口谈...
    ▪(十)装饰器模式详解(与IO不解的情缘)    ▪无锁编程:最简单例子    ▪【虚拟化实战】网络设计之四Teaming
    ▪OSGi:生命周期层    ▪Javascript/Jquery——简单定时器    ▪java代码 发送GET、POST请求
    ▪Entity Framework底层操作封装(3)    ▪HttpClient 发送GET、POST请求    ▪使用spring框架,应用启动时,加载数据
    ▪Linux下Apache网站目录读写权限的设置    ▪单键模式的C++描述    ▪学习ORM框架—hibernate(一):初识hibernate
     


    站内导航:


    特别声明:169IT网站部分信息来自互联网,如果侵犯您的权利,请及时告知,本站将立即删除!

    ©2012-2017,169IT.COM,E-mail:www_169it_com#163.com(请将#改为@)

    浙ICP备11055608号