博客园_自由港

spring 读取资源文件方法

2011-08-05T16:07:00Z

1.spring配置文件

2.读取属性方法

ApplicationContext c=new ClassPathXmlApplicationContext("classpath:applicationContext-datasource.xml");
Properties p=(Properties)c.getBean("configproperties");
System.out.println(p.getProperty("jdbcOrcale.driverClassName"));

本文链接

转 java 读取文件的字符集

2011-08-01T06:02:00Z

public static String getCharset(File file) {
        String charset = "GBK";
        byte[] first3Bytes = new byte[3];
        try {
            boolean checked = false;
            BufferedInputStream bis = new BufferedInputStream(
                  new FileInputStream(file));
            bis.mark(0);
            int read = bis.read(first3Bytes, 0, 3);
            if (read == -1)
                return charset;
            if (first3Bytes[0] == (byte) 0xFF && first3Bytes[1] == (byte) 0xFE) {
                charset = "UTF-16LE";
                checked = true;
            } else if (first3Bytes[0] == (byte) 0xFE && first3Bytes[1]
                == (byte) 0xFF) {
                charset = "UTF-16BE";
                checked = true;
            } else if (first3Bytes[0] == (byte) 0xEF && first3Bytes[1]
                    == (byte) 0xBB
                    && first3Bytes[2] == (byte) 0xBF) {
                charset = "UTF-8";
                checked = true;
            }
            bis.reset();
            if (!checked) {
                int loc = 0;
                while ((read = bis.read()) != -1) {
                    loc++;
                    if (read >= 0xF0)
                        break;
                    //单独出现BF以下的，也算是GBK
                    if (0x80 <= read && read <= 0xBF)
                        break;
                    if (0xC0 <= read && read <= 0xDF) {
                        read = bis.read();
                        if (0x80 <= read && read <= 0xBF)// 双字节 (0xC0 - 0xDF)
                            // (0x80 -
                            // 0xBF),也可能在GB编码内
                            continue;
                        else
                            break;
                     // 也有可能出错，但是几率较小
                    } else if (0xE0 <= read && read <= 0xEF) {
                        read = bis.read();
                        if (0x80 <= read && read <= 0xBF) {
                            read = bis.read();
                            if (0x80 <= read && read <= 0xBF) {
                                charset = "UTF-8";
                                break;
                            } else
                                break;
                        } else
                            break;
                    }
                }
                System.out.println(loc + " " + Integer.toHexString(read));
            }
            bis.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return charset;
    }

本文链接

dwr 读取cookie

2011-07-29T09:22:00Z

import org.directwebremoting.WebContextFactory;

HttpServletRequest req= WebContextFactory.get().getHttpServletRequest();
HttpSession session=WebContextFactory.get().getSession();

本文链接

JAVA实现AD验证

2011-03-22T03:33:00Z

package service;
import java.util.Hashtable;

import javax.naming.Context;

import javax.naming.NamingException;

import javax.naming.directory.DirContext;

import javax.naming.directory.InitialDirContext;

public class AuthAd
{
/**

* @param args

public static void main(String[] args) {

// TODO Auto-generated method stub

String userName = "aaa"; //用户名称

String password = "bbb"; //密码

String host = "192.168.40.17"; //AD服务器

String port = "389"; //端口

String domain = "@xxxx.xx"; //邮箱的后缀名

String url = new String("ldap://" + host + ":" + port);

String user = userName.indexOf(domain) > 0 ? userName : userName + domain;

Hashtable<String, String> env = new Hashtable<String, String>();

DirContext ctx;

env.put(Context.SECURITY_AUTHENTICATION, "simple");

env.put(Context.SECURITY_PRINCIPAL, user);

env.put(Context.SECURITY_CREDENTIALS, password);

env.put(Context.INITIAL_CONTEXT_FACTORY,"com.sun.jndi.ldap.LdapCtxFactory");

env.put(Context.PROVIDER_URL, url);

try {

ctx = new InitialDirContext(env);

ctx.close();

System.out.println("验证成功！");

} catch (NamingException err) {

err.printStackTrace();

System.out.println("验证失败！");

}
}

}

本文链接

JBPM FAQ

2011-03-12T15:41:00Z

1.如果在assignhandler 中取得当前的节点：

((ExecutionImpl) openExecution).getActivity()
2.动态创建连接。

public void createNewTransition(ProcessInstance processInstance ,String startActivity , String endActivity){
        String processDefinitionId = processInstance.getProcessDefinitionId();
        ProcessDefinitionImpl processDefinition =(ProcessDefinitionImpl)processEngine
            .getRepositoryService()
            .createProcessDefinitionQuery()
            .processDefinitionId(processDefinitionId)
            .uniqueResult();
        Execution execution = processInstance.findActiveExecutionIn(startActivity);
        if (execution == null) {
              System.out.println("在" + processDefinitionId + "中没有找到startActivity活动名称" + startActivity);
             }
        ExecutionImpl executionImpl = (ExecutionImpl) execution;
        Activity activity = executionImpl.getActivity();
        ActivityImpl activityFind = processDefinition.findActivity(endActivity);
         //判断在流程中是否有这个结点
         if (activityFind == null) {
          System.out.println("在" + processDefinitionId + "中没有找endActivity活动名称" + endActivity);
         }
         TransitionImpl transition = activityFind.createOutgoingTransition();
         String transitionName = startActivity + "-to-"+ endActivity;
         transition.setName(transitionName);
         transition.setDestination(activityFind);
         ((ActivityImpl)activity).addOutgoingTransition(transition);

         //验证
         Execution executionTemp = processInstance.findActiveExecutionIn(startActivity);
            ExecutionImpl executionImplTemp = (ExecutionImpl) execution;
         ActivityImpl activitytemp =(ActivityImpl)executionImpl.getActivity();
         List<Transition> transitions = activitytemp.getOutgoingTransitions();
         for(Transition transition1 : transitions){
             System.out.println("transition name"+ transition1.getName());
         }
    }

3.整合spring后如和从AssignHandler获取bean

把jbpm4与spring整合之后。

可以在assignmenthandler中通过EnvironmentImpl.getFromCurrent()获得spring中定义的bean。

在jpdl.xml中，直接设置了class，因此assignmenthandler没有被spring托管，不被spring管理的bean是不会从spring获得依赖的

4.获取当前流程实例所处的节点名字

List<ProcessInstance> processInstanceList = executionService.createProcessInstanceQuery().list();
for(ProcessInstance pi : processInstanceList){
pi.findActiveActivityNames()
}

5.概念 processinstance和execution的区别

两者是存储在一张表里的，两个接口的具体实现类也是一样的，都是ExecutionImpl。

区别是，当流程中拥有多个分支并发execution时，处于最顶级的execution就叫做ProcessInstance。

如果流程中没有并发，只有一条主线，那么这个execution就是processInstance。

在使用fork分支之后，一个processInstance下就会出现多个execution，每个execution指向对应的分支。

如果没有分支，就只有一个process instance，它既是execution又是process instance。所谓的process isntance就是没有parent的特殊execution。

6.从事件中获取Session

Session session = EnvironmentImpl.getFromCurrent(Session.class);

7.查询已完成的任务

historyService中没有提供直接查询已完成任务的途径，需要自己通过hibernate查询HistoryTaskImpl，查询条件为endTime is not null。
8.获取开始的活动。

processDefinitionImpl.getInital()就是第一个start活动

9.execution和task的关系是，task.getExecutionId()，通过task的executionId可以查询到对应的execution.

10.默认情况下，流程会按照顺序执行，第一个任务结束后才会创建第二个任务

如果想并行同时发起任务，使用fork join

11.获取当前活动对应的活动节点，要先通过task的name去查询任务对应的activity，然后获得activity所有的outgoingTransition，然后获得每个outgoingTransition的destination，也就是连线后面的节点了。

12.获取 TaskImpl task = (TaskImpl) taskService.getTask(taskId);

13.获取join活动完成的活动的个数，获得processInstance，找到childExecutions，判断有几个状态不是inactive-join。

14.通过historyService查询HistoryProcessInstance，没有结束时间的，是未完成的。有结束时间的，是已完成的。

15.Task是Execution执行到TaskActivity创建出来的，task完成后，会触发对应的Execution继续执行。

16.任务分配后，可以使用taskService.assignTask()进行任务的重新分配。

17.在监听器中获取任务实例的方法。TaskImpl task = EnvironmentImpl.getFromCurrent(DbSession.class).findTaskByExecution(execution);
18.任务节点

* 任务创建
   * 1.创建任务
   * 设置任务参数。
   * 2.设置人员
   *   设置执行人
   *   设置候选人
   *   设置候选组
   *   处理AssignHandler
   * 3.创建历史任务。

本文链接

JBPM使用assignHandler进行用户分派思路

2011-03-12T15:16:00Z

任务分派实现思路：

指派分两种情况：

1.定义流程的时候进行指派。

在流程定义的过程中，我们对步骤进行定义，指派执行人或者角色。

2.在流程运行的过程中指。

在流程执行过程中对下一步的任务进行指定执行人。

我们可以使用AssignHandler来实现这个具体的步骤。

我们可以事先定义好指定的流程变量如：

startUser,assign等。

如果发现流程变量中有这几个变量，就可以对流程的任务进行分派。

如果流程变量中没有定义这些流程变量，我们可以尝试从定义的数据库中取出该节点的人员进行任务指派。

本文链接

直接修改jpbm xml流程定义字段的方法

2011-03-12T14:39:00Z

找到了一个直接修改流程定义字段的方法。

package org.jbpm.pvm.internal.cmd;

import java.io.IOException;
import java.io.InputStream;

import org.jbpm.api.JbpmException;
import org.jbpm.api.cmd.Command;
import org.jbpm.api.cmd.Environment;
import org.jbpm.pvm.internal.session.RepositorySession;
import org.jbpm.pvm.internal.util.IoUtil;

/**
* @author Tom Baeyens
*/
public class UpdateDeploymentResourceCmd implements Command<Void> {

private static final long serialVersionUID = 1L;

protected String deploymentId;
protected String resourceName;
protected byte[] bytes;

public UpdateDeploymentResourceCmd(String deploymentId, String resourceName,
    InputStream inputStream) {
    this.deploymentId = deploymentId;
    this.resourceName = resourceName;
    try {
      bytes = IoUtil.readBytes(inputStream);
    }
    catch (IOException e) {
      throw new JbpmException("could not read resource: " + resourceName, e);
    }
    finally {
      IoUtil.close(inputStream);
    }
}

public Void execute(Environment environment) throws Exception {
    RepositorySession repositorySession = environment.get(RepositorySession.class);
    repositorySession.updateDeploymentResource(deploymentId, resourceName, bytes);
    return null;
}

}

本文链接

找到一篇jbpm session closed解决办法的文章

2011-03-03T06:12:00Z

在处理删除参数的过程中，发现报org.hibernate.LazyInitializationException:failed to lazily initialize a collection of role: org.jbpm.pvm.internal.model.ExecutionImpl.variables, no session or session was closed

代码如下：

ExecutionService executionService = processEngine.getExecutionService();
ProcessInstance executionService.createProcessInstanceQuery().processDefinitionId(processInstanceId).list();
((ExecutionImpl)processInstance2).removeVariable("aa");//删除变量aa时报错。因为Variable设置是延迟加载解决方式一：如果采用的是BS开发模式可以在web.xml中配制OpenSessionInViewFilter（注意：必须写在struts的配置下面）<filter>
        <filter-name>OpenSessionInViewFilter</filter-name>
        <filter-class>
            org.springframework.orm.hibernate3.support.OpenSessionInViewFilter
        </filter-class>
    </filter>
    <filter-mapping>
        <filter-name>OpenSessionInViewFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>在application.xml中加入

    <tx:annotation-driven transaction-manager="transactionManager"/>

<aop:aspectj-autoproxy />

<aop:config proxy-target-class="true">
        <aop:advisor pointcut="execution(* org.jbpm..*.*(..))"
            advice-ref="txAdvice" />
        <aop:advisor pointcut="execution(* com.jihong.jbpm.api.JbpmTemplate.*(..))"
                     advice-ref="txAdvice"/>
    </aop:config>

<tx:advice id="txAdvice">
        <tx:attributes>
            <tx:method name="get*" read-only="true" />
            <tx:method name="find*" read-only="true" />
            <tx:method name="pagedQuery*" read-only="true" />
            <tx:method name="load*" read-only="true" />
            <tx:method name="remove*" read-only="true" />
            <tx:method name="*" />
        </tx:attributes>
    </tx:advice>

解决方式二：通过processEngine的execute方式可以将一段代码放到一个Hibernate的事务里执行这样就可以避免延迟加载。
public class RemoveVarCommand implements Command<Void> {
    private String processInstanceId;
    private String varKey;
    public RemoveVarCommand(String processInstanceId,String varKey){
        this.processInstanceId=processInstanceId;
        this.varKey=varKey;
    }
    @Override
    public Void execute(Environment environment) throws Exception {
        ExecutionService executionService = environment.get(ExecutionService.class);
        ProcessInstance processInstance= executionService.findProcessInstanceById(processInstanceId);
        ((ExecutionImpl)processInstance).removeVariable(varKey);
        return null;
    }
}

processEngine.execute(new RemoveVarCommand(processInstance.getId(), "aa"));

每个命令都是一个独立的事务操作，每个excuete方法都被一个hibernate事务所包含,jbpm推荐使用这种方式扩展相关的功能。

本文链接

jsp 自定义标签的写法

2011-02-10T04:44:00Z

1.定义标签类。

标签扩展 BodyTagSupport 类。

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

-->package testtag;

import java.io.IOException;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspTagException;
import javax.servlet.jsp.JspWriter;
import javax.servlet.jsp.tagext.BodyTagSupport;
import javax.servlet.jsp.tagext.TagSupport;

public class LinkTag extends BodyTagSupport {

    public LinkTag() {
        // TODO Auto-generated constructor stub
    }

    private String href="";

    public String getHref() {
        return href;
    }

    public void setHref(String href) {
        this.href = href;
    }

    public int doStartTag() throws JspTagException {
        return EVAL_BODY_BUFFERED;
      }

      public int doEndTag() throws JspTagException {

        String body = this.getBodyContent().getString();
        HttpServletRequest request = (HttpServletRequest)pageContext.getRequest();

        try {
            JspWriter writer= pageContext.getOut();
            String str="<a href='"+this.href+"'>"+body+"</a>";
            pageContext.getOut().print(str);
        }
        catch (IOException e) {
          throw new JspTagException(e.getMessage());
        }
        return SKIP_BODY;
      }
}

2.定义标签文件 MyTagLib.tld。

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

--><?xml version="1.0" encoding="ISO-8859-1"?>
<taglib>
<tlib-version>1.0</tlib-version>
<jsp-version>1.2</jsp-version>
<tag>
  <name>linktag</name>
  <tag-class>testtag.LinkTag</tag-class>
  <body-content>jsp</body-content>
  <attribute>
    <name>href</name>
    <required>true</required>
    <rtexprvalue>true</rtexprvalue>
  </attribute>
</tag>

</taglib>

3.在web.xml中添加引用。

<jsp-config>
        <taglib>
            <taglib-uri>MyTagLib</taglib-uri>
            <taglib-location>/WEB-INF/MyTagLib.tld</taglib-location>
        </taglib>
    </jsp-config>

4.在页面中调用自定义标签。

<%@taglib uri="MyTagLib" prefix="mytag"%>
<mytag:linktag href="http://www.baidu.com">测试标签</mytag:linktag>

本文链接

jbpm 错误解决方法

2011-01-14T07:38:00Z

1.执行流程出现如下错误：

org.jbpm.pvm.internal.type.variable.UnpersistableVariable

出现错误的原因：

变量没有实现 Serializable 接口

解决办法：

变量需要实现 Serializable 接口。

2.java.lang.ClassCastException: $Proxy53 cannot be cast to oracle.sql.BLOB

出现错误原因：

我使用的是Hibernate 3.6版本。

解决办法：

在网上查到解决办法使用 hibernate3.5.4替换3.6.

3.项目启动第一次访问，发布流程没问题。但是第二次启动项目，再发布一个新流程的时候报如下错误.

2010-10-14 19:51:58,234 ERROR [org.hibernate.util.JDBCExceptionReporter] - 流已被关闭

org.hibernate.exception.GenericJDBCException: could not initialize a collection: [org.jbpm.pvm.internal.repository.DeploymentImpl.resources#1]
出现错误的原因是：

hibernate自动创建数据库时，配置文件中某些字段被hibernate解析成long类型。

在生成表后手动将LONG类型修改为字符串类型。

4.在发布流程的时候使用addResourceFromString方法发布流程，资源名称应该是以 .jpdl.xml 结尾的。

如果不是发布会不成功。

5.流程定义文件读取乱码的问题。

使用PL/SQL直接在数据库中查看是乱码，以为是Hibernate的问题。发现其他的数据都是正常的。

java.io.InputStream ss = repositoryService.getResourceAsStream(deployment,"process.jpdl.xml");

//在这里指定字符编码UTF-8。

BufferedReader in = new BufferedReader(new InputStreamReader(ss,"UTF-8"));

StringBuffer buffer = new StringBuffer();

while ((line = in.readLine()) != null){

buffer.append(line);

}

6.取得我的任务和候选任务。

jbpm 中我是用hql获取自己的当前任务和候选任务，发现重复记录使用distinct出错，发现出错的原因是在JBPM4_TASK表中的字段为clob类型，我将其修改成nvarchar类型，再使用distinct查询问题解决了。

StringBuffer hqlSb = new StringBuffer();
hqlSb.append("select distinct task from org.jbpm.pvm.internal.task.TaskImpl task left join task.participations pt where task.assignee=?");
hqlSb.append(" or task.assignee is null and ((pt.type = 'candidate' and pt.userId =? ) ");

if (groups.length()> 0) {
          hqlSb.append(" or pt.groupId in (" +groups + ")");
        }
        hqlSb.append(")");
        hqlSb.append(" order by task.createTime desc");

本文链接