hibernate ID 生成方式

发表于 2015-02-10 更新于 2025-01-01 分类于 JAVA 阅读次数：

1、assigned

主键由外部程序负责生成，在 save() 之前必须指定一个。Hibernate不负责维护主键生成。与Hibernate和底层数据库都无关，可以跨数据库。在存储对象前，必须要使用主键的setter方法给主键赋值，至于这个值怎么生成，完全由自己决定，这种方法应该尽量避免。

“ud”是自定义的策略名，人为起的名字，后面均用“ud”表示。

特点：可以跨数据库，人为控制主键生成，应尽量避免。

2、increment

由Hibernate从数据库中取出主键的最大值（每个session只取1次），以该值为基础，每次增量为1，在内存中生成主键，不依赖于底层的数据库，因此可以跨数据库。

Hibernate调用org.hibernate.id.IncrementGenerator类里面的generate()方法，使用select max(idColumnName) from tableName语句获取主键最大值。该方法被声明成了synchronized，所以在一个独立的Java虚拟机内部是没有问题的，然而，在多个JVM同时并发访问数据库select max时就可能取出相同的值，再insert就会发生Dumplicate entry的错误。所以只能有一个Hibernate应用进程访问数据库，否则就可能产生主键冲突，所以不适合多进程并发更新数据库，适合单一进程访问数据库，不能用于群集环境。

阅读全文 »

windows核心编程-错误处理

发表于 2015-01-29 更新于 2025-01-01 分类于 ACMICPC 阅读次数：

1.常见的错误返回类型

VOID/BOOL/HANDLE/PVOID/LONG/DWORD VOID 不可能失败 BOOL 错误返回false 编码的时候最好测试是否不为FALSE HANDLE 错误 NULL/INVALID_HANDLE_VALUE PVOID 失败返回NULL,成功返回一个数据块的地址 LONG/DWORD 0或-1，不绝对 2.GetLastError函数 DWORD GetLastError(); 3.WinError.h 头文件定义了若干的Mircosoft定义的代码列表 4.

IOCP

发表于 2015-01-29 更新于 2025-01-01 分类于 Theory 阅读次数：

IOCP是windows下的一种异步IO通信模式（linux下面对应epoll，二者有区别—>http://www.cnblogs.com/uzhang/archive/2012/02/24/2365980.html）

一样的socket的绑定通信的过程，不同的是并不对每一个用户请求单独开设一个线程去处理用户请求，而是在后面一线程池的方式，开固定的线程，轮流处理用户请求，减少线程的上下文切换损耗，同时利用重叠IO，减低内存等资源的消耗。关于具体的一些内容，见：http://blog.csdn.net/neicole/article/details/7549497

Xchart 源码分析（1）

发表于 2014-12-22 更新于 2025-01-01 分类于 SourceReading 阅读次数：

学校课程需要找一份代码，来讲讲代码里面用了哪些设计模式- -！还是要java的。。。于是上github上面翻代码，偶然翻到一个java的xchart图标库，感觉可能以后会用的到，而且代码不是很长，就直接拿过来用了。具体的链接地址如下：https://github.com/timmolter/XChart

先看文件夹结构：

一共有6个包，最后一个是用来测试的包，可以忽略不计，一共5个包，5个包的作用分别是

com.xeiam.xchart:
主要是图表生成的代码以及一些图表的功能包括导出功能的代码，是给我们使用该jar包人调用的结构，表示的是一个图表整体的构造，包括Chart,ChartBuild,Series等类。
com.xeiam.xchart.internal
这个package里面只有两个类，一个是package-info，我也不是很明白他的作用。。。就是写了一个license的地址。另一个类是Utils的类，提供了两个静态方法，一个求幂的，一个就是求差值的一半。

阅读全文 »

设计模式-代理模式

发表于 2014-09-08 更新于 2025-01-01 分类于 Design Pattern 阅读次数：

在实际开发的时候，我们同样的一个对象，对于不同的客户，可能能够调用的方法是不一样的，就是权限的控制，这个时候，对象的方法都应该是public，那么就要给对象加上一层，通过客户的类型，决定是否可以访问，也就是说，客户不直接访问对象，而是访问给对象加上的这一层，就是代理层。

public interface T1{
    public void method();
};
public class Item implements T1{
    public void method();
}
public class ItemProxy implements T1{
    Item item;
    Client client;
    public ItemProxy(Client c){
        this.Client=c;
        this.item=new item();
    }
    public void method(){
        if (client,allow()){    
            item.method1();
        }else{
            return;
        }
    }
}
public class Client{
    T1 t;
    public Client()    
    {
        t=new ItemProxy(this);
    }
    public void method1()
    {    
        t.method();    
    }    
}

这样就可以在代理类中，控制对象的访问了，当然代理模式实现方式还有很多种，（远程代理管理客户和远程对象的交互，虚拟代理控制访问实例化开销大的对象，保护代理基于调用者控制对对象方法的访问），上面只是其中的一种方式，代理模式的定义如下：

阅读全文 »

设计模式-状态模式

发表于 2014-09-07 更新于 2025-01-01 分类于 Design Pattern 阅读次数：

状态模式是针对系统的状态转换的，其主要的定义如下：

1	状态模式：允许对象在内部状态改变时改变他的行为，对象看起来好像修改了它的类。

为了方便状态转移我们为状态定义一个通用的接口，然后每一种状态都实现这个接口，而在系统类中，通过构造函数，将系统本身传入状态类中，这样，每一种状态的改变，都可以在自己类的内部完成，同时提高了可扩展性：

public interface State{
    public void des();
    public void action();
}
public class State1 implements State{
    Sys sys;
    public Sate1(Sys s)
    {
        this.sys=sys;
    }
    public void des(){
        .../ implements
    }
    public void action(){
        .../ change the state
        sys.setState(s.getState2());
    }
}
public class State2 implements State{
    Sys sys;
    public Sate2(Sys s)
    {
        this.sys=sys;
    }
    public void des(){
        .../ implements
    }
    public void action(){
        .../ change the state
        sys.setState(s.getState1());
    }
}
public class Sys {
    private State1 state1;
    private State2 state2;
    private State state;//record the system's state
    ....//state1 & state2's setter & getter
    public Sys(State state)
    {
        this.state=state;
    }
    public void setState(State state)
    {    
        this.state=state;
    }    
    public void aciton()
    {
        state.action();
    }
}

虽然在实现上状态模式和策略模式以及模板方法有些相似但是几个设计模式完全不一样，策略模式是将可以互换的行为封装起来，然后使用委托的方法决定使用哪一个行为，模板方法则是由子类决定具体的如何实现算法中的某些步骤，而算法的流程是给定的，而状态模式则封装的是基于状态的行为，并将行为委托到当前状态，由当前状态来决定具体行为。

设计模式-迭代器模式和组合模式

发表于 2014-09-06 更新于 2025-01-01 分类于 Design Pattern 阅读次数：

1.迭代器模式完成的功能是和迭代器一样的，封装了对对象的顺序遍历，因为子类的对象集合的存储方式可能并不一致。但是存储的对象是一致的。

public classItem{
    .....//各种属性
}
public class Set1{
    item[] items;
    ...
    public Iterator createIterator(){
        return new ItemIterator(items);
    }
}
public class Set2{
    ArrayList items;
    ...
    public Iterator createIterator(){
        return  items.iterator();
    }
}
public class ItemIterator implements Iterator{
    Item[] items;
     int position;
    public ItemIterator(Item[] items)
    {
        this.items=items;
        position=0;
    }
    public Object next()
    {
        Item i=items[position];
        position=position+1;
        return i;
    }
    public boolean hasNext()
    {
        if (position>=items.lenght || items[position]==null)
            return false;
        else
            return true;
    }
}

通过这种方法，我们就可以通过自己定义的一个迭代器来访问数组，同时通过createIterator的方法来顺序遍历存储结构不一样的Set1和Set2中item对象。所以迭代器模式就是:

1	迭代器模式：提供一种方法顺序访问一个聚合对象中的各种元素，而又不暴露其内部的表示。

2.组合模式

组合模式其实就是整体与部分的一个关系，其实就是一个树形结构，根节点由他的子节点组合而成，而子节点又有自己的子节点来组合而成，所以组合模式的定义如下：

阅读全文 »

设计模式-模板方法

发表于 2014-09-05 更新于 2025-01-01 分类于 Design Pattern 阅读次数：

前面学习过了策略模式，策略模式是对一类的算法进行封装，利用组合，算法之间可以互相替换，但是这个是针对算法过程不是一样的算法。但是如果一系列的算法的步骤都是一样的，且算法的很多过程都是一样的处理，那么，用策略模式的话，会导致算法的重用不高，我们采用模板方法来实现：

模板方法模式：在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。

public abstract class CAL{
    public final void algorithm()
    {
        A1();
        A2();
        if (Judge())
            A3();
        A4();
    }
    public void A1(){
        //实现
        .....
    }
    public  void A2(){
        //实现
        .....
    }
    public abstract void A3(){}
    public abstract void A4(){}
    public boolean Judge(){
        return true;
    }
}

其中模板类是一个抽象类，其中算法是确定了的，A1，A2是公共的方法，所有的子类都是一样的，A3，A4是子类自己实现的不一样的函数，定义为抽象方法，子类实现，而Judge方法被成为钩子，默认返回true，而子类可以重写这个方法，这样就能让子类拥有自己的方法。但是这个也反应了模板方法的一个缺点，就是与策略模式相比，弹性不足。

阅读全文 »

设计模式-适配器模式和外观模式

发表于 2014-09-04 更新于 2025-01-01 分类于 Design Pattern 阅读次数：

1.适配器模式

适配器模式是针对接口不一时处理的情况，比如我的类的参数是IInterface1，但是我现在想要调用IInterface2接口的函数，怎么办呢？就是用适配器来解决这个问题：

public interface IInterface1(){
    public void method1();
}
public interface IInterface2(){
    public void method2();
}
public class adapter implements IInterface1{
    IInterface2 v;
    public adapter(IInterface2 t){
        this.v=t;
    }
    public void method1(){
        v.method2();
    }
}

现在我们调用IIterface2的method1的方法的时候，就是可以直接构造一个适配器来完成

public class A{

    public void method3(IInterface1 t)
    {
        t.method1();
    }

    public static void main(String[] arg)
    {
        (new A()).method3(new adapter(claimplementInterfce2));
    }
}

其中claimplementInterface2是实现Interface2的一个类的实例。这种适配器的方法被称作为对象适配器，还有一种适配器，叫做类适配器，是基于类的多继承的，其中适配器继承自要适配的两个类，用其中一个类的方法调用另一个类，思想是一致的，不过java不支持多继承，所以也就是只能用对象适配器。

阅读全文 »

设计模式-命令模式

发表于 2014-09-03 更新于 2025-01-01 分类于 Design Pattern 阅读次数：

命令模式这个设计模式更像是对接口编程的一种应用，比如给小朋友穿衣服，但是不一样的衣服有不一样的穿法，裤子，衬衫，鞋，T恤都是不一样的，但是小朋友不知道怎么穿，只知道想穿什么，那么怎么办呢，小朋友会让他的妈妈帮他穿，这里面的“让妈妈帮忙”，就是给妈妈一个命令（虽然不是很恰当- -！），对小朋友而言，怎么穿他并不关心，反正只要有只要让妈妈穿就行了，所以我们只要定义一个穿的接口就行

public interface Wear()
{
    public void excute();
}

然后继承这个穿，有很多种执行方式，比如穿鞋，穿衬衫，穿裤子

public class WearShoe implements Wear{
    public void excute()
    {
        .....//穿鞋的动作    
    }
}
public class WearShirt implements Wear{
    public void excute()
    {
        .....//穿衬衫的动作    
    }
}
public class WearPants implements Wear{
    public void excute()
    {
        .....//穿裤子的动作    
    }
}

阅读全文 »