当前位置:  编程技术>软件工程/软件设计

[1]使用最多的9种License

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 

允许各种链接，但被链接的整个产品需要开源

允许修改，但被修改部分及整个产品均需要开源

仅原则性声明专利应免费许可，无详细规定

注释：谨慎使用，由于可能导致产品整体负有开源义务，不建议使用

[2]设计模式之五S:动态代理模式（Dynamic Proxy Pattern）

       代理模式的作用是：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个客户不想或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。   抽象角色：声明真实对象和代理对象的共同接口；
代理角色：代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。
真实角色：代理角色所代表的真实对象，是我们最终要引用的对象。
按照代理的创建时期，代理类可以分为两种。 
静态代理：由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.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]大话设计模式——简单工厂模式

简单工厂模式解释： 

       简单工厂模式（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;
}

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