select new DepartmentView(d.poin,count(e.poin)) from Department d inner join d.employeeSet group by d.poin.

<plug-in className="org.springframework.web.struts.ContextLoaderPlugIn"/>  
    <set-property property="contextConfigLocation" value="/WEB-INF/applicationContext.xml"/>  
</plug-in>

<servlet>
    <servlet-name>action</servlet-name>
    <servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
    <load-on-startup >1</load-on-startup >
</servlet>  
<servlet-mapping>
    <servlet-name>action</servlet-name>
    <url-pattern>*.do</url-pattern>
</servlet-mapping>

<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

<context-param>  
        <param-name>contextConfigLocationparam-name>  
        <param-value>classpath*:spring/*.xmlparam-value>  
</context-param>

<servlet>
        <servlet-name>context</servlet-name>    
        <servlet-class>org.springframework.web.context.ContextLoaderServlet</servlet-class>    
        <load-on-startup>1</load-on-startup>
</servlet>

package com.pattern.command;  
/**  
*接受者（相当于厨师）  
*/  
public class Receiver {  
      
    public void doReceiverAction(){  
        System.out.println("接受者执行完毕");  
    }  
  
}  

package com.pattern.command;
/**
*接受者（相当于厨师）
*/
public class Receiver {
  
  public void doReceiverAction(){
    System.out.println("接受者执行完毕");
  }

}


package com.pattern.command;  
/**  
*命令角色  
*/  
public interface Command {  
      
    public void execute();  
  
}  

package com.pattern.command;
/**
*命令角色
*/
public interface Command {
  
  public void execute();

}


package com.pattern.command;  
  
/**  
* 具体命令角色,调用接受者执行具体命令。自己不能执行具体命令，所以需要创建一个接受者对象  
*/  
public class CommandImpl implements Command{  
  
    private Receiver receiver;  
    public CommandImpl(Receiver receiver){  
        this.receiver = receiver;  
    }  
    public void execute(){  
        receiver.doReceiverAction();  
    }  
}  

package com.pattern.command;

/**
* 具体命令角色,调用接受者执行具体命令。自己不能执行具体命令，所以需要创建一个接受者对象
*/
public class CommandImpl implements Command{

  private Receiver receiver;
  public CommandImpl(Receiver receiver){
    this.receiver = receiver;
  }
  public void execute(){
    receiver.doReceiverAction();
  }
}


package com.pattern.command;  
/**  
* 请求者角色，需要发出一个命令，所以需要创建一个命令角色的对象.(相当于顾客)  
*/  
public class ReqRole {  
  
    private Command command;  
    public ReqRole(Command command){  
        this.command = command;  
    }  
    public  void  doAction(){  
        command.execute();  
    }  
      
}  

package com.pattern.command;
/**
* 请求者角色，需要发出一个命令，所以需要创建一个命令角色的对象.(相当于顾客)
*/
public class ReqRole {

  private Command command;
  public ReqRole(Command command){
    this.command = command;
  }
  public  void  doAction(){
    command.execute();
  }
  
}

package com.pattern.command;  
/**  
*客户角色  
*/  
public class Test {  
      
    public static void main(String[] args){  
          
        Receiver receiver = new Receiver();//接受者。不和任何对象关联  
          
        Command command = new CommandImpl(receiver);//构建一个命令角色。因为自己不执行任何命令，真正执行命令的是接受者，所以需要传递一个接受者对象  
          
        ReqRole reqRole = new ReqRole(command);//请求角色。因为需要请求一个命令，所以需要接受一个命令角色对象  
      
        reqRole.doAction();  
    }  
      
  
}  

package com.pattern.composite;  
/**  
* 组件抽象角色  
*  
*/  
public interface Component {  
      
    public void run();  
  
}  

package com.pattern.composite;
/**
* 组件抽象角色
*
*/
public interface Component {
  
  public void run();

}

package com.pattern.composite;  
/**  
* 叶子角色  
*  
*/  
public class Leaf implements Component{  
      
    public void run(){  
        System.out.println(" run invoked...");  
    }  
  
}  

package com.pattern.composite;
/**
* 叶子角色
*
*/
public class Leaf implements Component{
  
  public void run(){
    System.out.println(" run invoked...");
  }

}

package com.pattern.composite;  
  
import java.util.ArrayList;  
import java.util.List;  
/**  
* 组合角色  
* 实现组件角色接口，并且添加，删除的也是组件角色  
*  
* Composite本来可以再包含Leaf和Composite的。而 Leaf和Composite 又都属于 Component，所以增加，删除 的是Component  
*  
* 组合模式主要分为2种  
*  
* 1 透明式  

    添加Component对象的操作定义在Component角色中，这样的话不仅Composite需要实现这些方法，Leaf也需要实现这些方法，  
    而这些方法对于Leaf来说没有任何意义，不过将系统实现统一起来了，因此对用户来说透明（用户无需区分Composite还是Leaf）  
    ，因为这些角色中都具备这些方法。  
      
   2 安全式  

    添加Component对象的操作定义在Composite角色中，这样的话Leaf就无需实现这些方法（因为Leaf本身根本不需要实现这些方法）  
*  
*/  
public class Composite  implements Component{  
      
    List<Component> list = new ArrayList<Component>();  
      
    //添加  
    public void addComponent(Component component){  
        list.add(component);  
    }  
    //删除  
    public void removeComponent(Component component){  
        list.remove(component);  
    }  
      
    //get  
    public List<Component> getAll(){  
        return list;  
    }  
      
    public void run(){  
        for(Component component : list){  
            component.run();  
        }  
    }  
  
}  

package com.pattern.composite;

import java.util.ArrayList;
import java.util.List;
/**
* 组合角色
* 实现组件角色接口，并且添加，删除的也是组件角色
*
* Composite本来可以再包含Leaf和Composite的。而 Leaf和Composite 又都属于 Component，所以增加，删除 的是Component
*
* 组合模式主要分为2种
*
* 1 透明式

  添加Component对象的操作定义在Component角色中，这样的话不仅Composite需要实现这些方法，Leaf也需要实现这些方法，
  而这些方法对于Leaf来说没有任何意义，不过将系统实现统一起来了，因此对用户来说透明（用户无需区分Composite还是Leaf）
  ，因为这些角色中都具备这些方法。
  
   2 安全式

  添加Component对象的操作定义在Composite角色中，这样的话Leaf就无需实现这些方法（因为Leaf本身根本不需要实现这些方法）
*
*/
public class Composite  implements Component{
  
  List<Component> list = new ArrayList<Component>();
  
  //添加
  public void addComponent(Component component){
    list.add(component);
  }
  //删除
  public void removeComponent(Component component){
    list.remove(component);
  }
  
  //get
  public List<Component> getAll(){
    return list;
  }
  
  public void run(){
    for(Component component : list){
      component.run();
    }
  }

}

package com.pattern.composite;  
  
public class Client {  
  
    public static void main(String[] args){  
        Leaf leaf1 = new Leaf();  
        Leaf leaf2 = new Leaf();  
        Leaf leaf3 = new Leaf();  
          
        Composite composite = new Composite();  
          
        composite.addComponent(leaf1);  
        composite.addComponent(leaf2);  
          
        Composite composite1 = new Composite();  
        composite1.addComponent(composite);  
        composite1.addComponent(leaf3);  
          
        composite1.run();  
          
    }  
}  

package com.pattern.adapter.classadapter;  
/**  
* 客户端要使用的目标类  
*  
*/  
public interface Target {  
      
    public void method1();  
  
}  

package com.pattern.adapter.classadapter;
/**
* 客户端要使用的目标类
*
*/
public interface Target {
  
  public void method1();

}

package com.pattern.adapter.classadapter;  
  
public class Adaptee {  
      
    public void method2(){  
        System.out.println("执行...");  
    }  
  
}  

package com.pattern.adapter.classadapter;
public class Adaptee {
  
  public void method2(){
    System.out.println("执行...");
  }

}

package com.pattern.adapter.classadapter;  
//继承Adaptee类  
public class Adapter extends Adaptee implements Target {  
  
    //包装类  
    public void method1() {  
        this.method2();  
    }  
  
}  

package com.pattern.adapter.classadapter;
//继承Adaptee类
public class Adapter extends Adaptee implements Target {

  //包装类
  public void method1() {
    this.method2();
  }

}
package com.pattern.adapter.classadapter;  
//适配器模式也叫包装模式  
public class Client {  
    //类适配器模式  
    public static void main(String[] args){  
        Target target = new Adapter();  
        target.method1();  
    }  
  
}  

package com.pattern.adapter.classadapter;
//适配器模式也叫包装模式
public class Client {
  //类适配器模式
  public static void main(String[] args){
    Target target = new Adapter();
    target.method1();
  }

}

package com.pattern.adapter.objectadapter;  
/**  
* 客户端要使用的目标类  
*  
*/  
public interface Target {  
    public void method1();  
}  

package com.pattern.adapter.objectadapter;
/**
* 客户端要使用的目标类
*
*/
public interface Target {
  public void method1();
}

package com.pattern.adapter.objectadapter;  
  
public class Adaptee {  
      
    public void method2(){  
        System.out.println("执行...");  
    }  
  
}  

package com.pattern.adapter.objectadapter;

public class Adaptee {
  
  public void method2(){
    System.out.println("执行...");
  }

}

package com.pattern.adapter.objectadapter;  
  
//不继承Adaptee类  
public class Adapter implements Target {  
  
    private Adaptee adaptee ;  
    public Adapter(Adaptee adaptee){  
        this.adaptee = adaptee;  
    }  
      
    public void method1() {  
        adaptee.method2();  
    }  
  
}  

package com.pattern.adapter.objectadapter;

//不继承Adaptee类
public class Adapter implements Target {

  private Adaptee adaptee ;
  public Adapter(Adaptee adaptee){
    this.adaptee = adaptee;
  }
  
  public void method1() {
    adaptee.method2();
  }

}
package com.pattern.adapter.objectadapter;  
//适配器模式也叫包装模式  
public class Client {  
    //对象适配器模式  
    public static void main(String[] args){  
        Target target = new Adapter(new Adaptee());  
        target.method1();  
    }  
  
}