跟我一步一步开发自己的Openfire插件

http://www.blogjava.net/hoojo/archive/2013/03/07/396146.html

跟我一步一步开发自己的Openfire插件

这篇是简单插件开发，下篇聊天记录插件。

开发环境：

System：Windows

WebBrowser：IE6+、Firefox3+

JavaEE Server：tomcat5.0.2.8、tomcat6

IDE：eclipse、MyEclipse 8

开发依赖库：

Jdk1.6、jasper-compiler.jar、jasper-runtime.jar、openfire.jar、servlet.jar

Email：[email protected]

Blog：http://blog.csdn.net/IBM_hoojo

http://hoojo.cnblogs.com/

在开始之前，如果你不知道怎么使用openfire，安装openfire服务器，建议你看这篇文章：

http://www.cnblogs.com/hoojo/archive/2012/05/17/2506769.html

http://www.cnblogs.com/hoojo/archive/2012/05/13/2498151.html

一、准备工作

1、 下载相关jar包和openfire源码

Openfire源码下载：http://www.igniterealtime.org/downloads/download-landing.jsp?file=openfire/openfire_src_3_8_0.tar.gz

其他的jar包你可以去tomcat中的lib目录找到或者其他的地方也有（在下面的步骤会提到），这里就赘述了。

2、 新建一个自己的java project工程，添加的jar包如下：

将jasper-compiler.jar、jasper-runtime.jar、servlet.jar添加到新建的工程中。如果没有jar先不要急，看下面的步骤：

下载后的openfire源码目录是这样的

如果你有ant工具可以用dos命令行的方式，直接运行build目录中的ant脚本，运行脚本后，你会发现有一个target的目录。该目录如下：

在lib目录中可以找到我们需要的jar文件了，将openfire.jar也添加到你的工程中。

如果你没有安装ant你可以用MyEclipse，将openfire源码中的build、documentation、resources目录复制到一个Java Project中，然后在MyEclipse中运行src中的build.xml ant脚本就会出现和上面一样的文件目录。

建议将你的MyEclipse中的openfire源码工程目录设置成这样的

其中，src/plugins/tree是我自己写的插件，现在暂时可以无视。而target就是我们需要的，里面存放了openfire的配置和需要的jar包。Work是工作目录，是一个完整的openfire服务器。如果你还没有下载openfire服务器的话，可以用这个服务器。

3、 了解openfire源码中的插件

我们找一个插件目录看看，主要看看里面的结构，目录结构很重要。因为我们将写好的插件打成jar包后，打包的jar的目录有一定规范结构，不能随便建立其他目录。

这是一个userservice的插件，在src/java中是我们的插件源代码；web目录中则是前端的页面，其中web-custom.xml是配置当前插件UserServiceServlet配置；changelog.html是修改日志；logo_small.gif是插件图标；plugin.xml是我们配置插件的文件，这个很重要（在这里先提示下）；

二、开发简单插件

工程现在的目录机构如下

1、 建立自己的插件类，SamplePlugin.java，里面简单的写点内容。

package com.hoo.server.plugin;
 
import java.io.File;
import org.jivesoftware.openfire.XMPPServer;
import org.jivesoftware.openfire.container.Plugin;
import org.jivesoftware.openfire.container.PluginManager;
 
/**
 * <b>function:</b> openfire server plugin sample
 * @author hoojo
 * @createDate 2013-2-28 下午05:48:22
 * @file SamplePlugin.java
 * @package com.hoo.server.plugin
 * @project OpenfirePlugin
 * @blog http://blog.csdn.net/IBM_hoojo
 * @email [email protected]
 * @version 1.0
 */
public class SamplePlugin implements Plugin {
 
    private XMPPServer server;
    
    @Override
    public void initializePlugin(PluginManager manager, File pluginDirectory) {
        server = XMPPServer.getInstance();
        System.out.println("初始化…… 安装插件！");
        System.out.println(server.getServerInfo());
    }
 
    @Override
    public void destroyPlugin() {
        System.out.println("服务器停止，销毁插件！");
    }
}

比较简单，如果你将插件安装在openfire服务器上的时候，启动服务器一个可以看到初始化的内容，关闭服务器可以看到销毁的内容。

2、 配置插件

<?xml version="1.0" encoding="UTF-8"?>
<plugin>
<!-- Main plugin class  这里是最重要滴，就是你的插件的全路径-->
<class>com.hoo.server.plugin.SamplePlugin</class>
 
<!-- Plugin meta-data -->
<name>SimplePlugin</name>
<description>This is the my sample plugin.</description>
<author>hoojo</author>
 
<version>1.0</version>
<date>28/02/2013</date>
<url>http://localhost:9090/openfire/plugins.jsp</url>
<minServerVersion>3.4.1</minServerVersion>
<licenseType>gpl</licenseType>
 
<adminconsole>    
    </adminconsole>
</plugin>

注意上面的class的配置，那个配置是最为重要的，配置的是插件的全路径；name是插件的名称，安装后的插件名称；author是插件作者；lincenseType是协议；adminconsole是配置插件关联的页面的；稍后再讲！

3、 可部署的插件包jar的目录结构

这个很重要，目录结构将决定你插件 发布的成败。

在编写命令之前，我们可以看看openfire服务器中已经安装的插件的jar包的目录结构，到时候我们也要打包成那样的结构才行的。必须打包成这样的目录结构，否则哼哼……后果很严重的！声明！

在我机器中的openfire服务器中，插件目录在C:\Program Files\openfire\plugins，里面有一个search.jar插件。提示：当你将一个可以安装的jar安装在openfire后，会被openfire解压成目录结构。就向JavaEE中的war包发布的应用服务器中的效果一样的。

打成可部署的插件jar包（相当于发布的应用服务器的目录结构）的search.jar目录结构如下：

首先看看文件命名，search.jar就是我们打包的插件的名称，而国际化的配置文件就是以插件名称开头_118n.properties或插件名称开头_118n_language.properties；而lib目录中的是插件的src目录的class打成的jar包；带有*-jspc.jar是web目录下的jsp编译成servlet后的class打成的包文件，都是以插件名称开头；WEB-INF/web.xml配置的是*-jspc.jar中的class文件；web/images是图片文件，需要用到的图片都放置在这个目录即可；plugin.xml文件名固定的，里面是配置插件的xml内容。

其中，118n国际化文件，它主要是我们在插件中的jsp和Java程序中的国际化配置。Web目录存放jsp、图片、web.xml内容；lib目录是存放插件的src目录的java代码编译后打包的jar，以及jsp编译成servlet的class打包后的jar；其他的文件都是根目录的；

对照上面插件包的jar，我们看看实际开发中的目录结构：

稍提醒下，如果你的插件中包含servlet，那你需要将它配置在web目录下的WEB-INF/web-custom.xml目录中；这个在以后会经常用到的，比如你提供一个接口给外部程序调用的情况下。目录结构参考：

UserServiceServlet配置在web-custom.xml目录中。

4、 编写ant命令，打可部署jar包。如果你不懂ant命令也没关系，你总知道java的基本常用的dos命令。只不过ant就是将dos转换成一个可重复多次调用的命令行。

在工程的根目录中新建一个build目录，新建

build.xml

<project name="Webapp Precompilation" default="openfire-plugins" basedir=".">
    <property file="build.properties" />
    
    <!-- java servlet相关文件编译jar存放位置 -->
    <property name="java.jar.dir" value="${webapp.path}/java-dist"/>
    <!-- jsp servlet编译后jar存放位置 -->
    <property name="jsp.jar.dir" value="${webapp.path}/jsp-dist/lib"/>
        
    <!-- 定义java servlet和jsp servlet的jar包名称 -->
    <property name="java.jar" value="${java.jar.dir}/plugin-${plugin.name}.jar"/>
    <property name="jsp.jar" value="${jsp.jar.dir}/plugin-${plugin.name}-jsp.jar"/>
    
    <!-- jsp servlet配置到web.xml中 -->
    <property name="plugin.web.xml" value="${webapp.path}/jsp-dist/web.xml"/>
        
    <!-- 编译jsp 并生成相关jar、xml文件 -->
    <target name="jspc">
        
        <taskdef classname="org.apache.jasper.JspC" name="jasper2">
            <classpath id="jspc.classpath">
                <pathelement location="${java.home}/../lib/tools.jar" />
                <fileset dir="${tomcat.home}/bin">
                    <include name="*.jar" />
                </fileset>
                <fileset dir="${tomcat.home}/server/lib">
                    <include name="*.jar" />
                </fileset>
                <fileset dir="${tomcat.home}/common/lib">
                    <include name="*.jar" />
                </fileset>
                <!--
                <fileset dir="D:/Workspace/openfire/build/lib">
                    <include name="**/*.jar" />
                </fileset-->
            </classpath>
        </taskdef>
                    
        <!-- 编译jsp->servlet class -->
        <jasper2 javaEncoding="UTF-8" validateXml="false"
            uriroot="${plugin.path}/web"
            outputDir="${webapp.path}/jsp-dist/src"
            package="com.hoo.openfire.plugin.${plugin.name}" />
        
        <!-- 编译后的servlet class 配置到web.xml文件中 -->
        <jasper2
            validateXml="false"
            uriroot="${plugin.path}/web"
            outputDir="${webapp.path}/jsp-dist/src"
            package="com.hoo.openfire.plugin.${plugin.name}"
            webXml="${plugin.web.xml}"/>
    </target>
    
    <!-- 编译jsp 并将其打jar包 -->
    <target name="compile">
 
        <mkdir dir="${webapp.path}/jsp-dist/classes" />
        <mkdir dir="${webapp.path}/jsp-dist/lib" />
        <mkdir dir="${webapp.path}/jsp-dist/src" />
        
        <javac destdir="${webapp.path}/jsp-dist/classes" optimize="off"
            encoding="UTF-8" debug="on" failonerror="false"
            srcdir="${webapp.path}/jsp-dist/src" excludes="**/*.smap">
            <classpath>
                <pathelement location="${webapp.path}/jsp-dist/classes" />
                <fileset dir="${webapp.path}/jsp-dist/lib">
                    <include name="*.jar" />
                </fileset>
                <pathelement location="${tomcat.home}/common/classes" />
                <fileset dir="${tomcat.home}/common/lib">
                    <include name="*.jar" />
                </fileset>
                <pathelement location="${tomcat.home}/shared/classes" />
                <fileset dir="${tomcat.home}/shared/lib">
                    <include name="*.jar" />
                </fileset>
                <fileset dir="${tomcat.home}/bin">
                    <include name="*.jar" />
                </fileset>
            </classpath>
            <include name="**" />
            <exclude name="tags/**" />
        </javac>
        
        <jar jarfile="${jsp.jar}" basedir="${webapp.path}/jsp-dist/classes" />
    </target>
 
    <!-- 将java servlet打包成jar -->
    <target name="java-jar">
        <mkdir dir="${java.jar.dir}"/>
        <jar jarfile="${java.jar}">
            <fileset dir="${webapp.path}/bin" includes="**/*.class"/>
        </jar>    
    </target>    
 
    <!-- 生成可部署的插件包 -->
    <target name="plug-jar">
        <!-- 插件插件包相关lib、 web目录 -->
        <mkdir dir="${webapp.path}/${plugin.name}/lib"/>
        <mkdir dir="${webapp.path}/${plugin.name}/web/WEB-INF"/>
 
        <!-- 复制jsp servlet的jar和java servlet的相关jar包到插件包的lib目录下 -->
        <copy file="${java.jar}" todir="${webapp.path}/${plugin.name}/lib"/>
        <copy file="${jsp.jar}" todir="${webapp.path}/${plugin.name}/lib"/>
 
        <!-- 将相关的图片、帮助文档、修改日志等文件复制到插件目录下 -->
        <copy todir="${webapp.path}/${plugin.name}">
            <fileset dir="${plugin.path}" includes="*.*"/>
        </copy>
        <copy todir="${webapp.path}/${plugin.name}/web">
            <fileset dir="${plugin.path}/web">
                <include name="*"/>
                <include name="**/*.*"/>
                <exclude name="**/*.xml"/>
                <exclude name="**/*.jsp"/>
            </fileset>
        </copy>
        <!-- jsp servlet的web复制到插件目录下 -->
        <copy file="${plugin.web.xml}" todir="${webapp.path}/${plugin.name}/web/WEB-INF"/>
        <copy todir="${webapp.path}/${plugin.name}/web">
            <fileset dir="${plugin.path}/web" includes="**/*.xml"/>
        </copy>
        <!-- 将国际化相关资源文件复制到插件目录下 
        <copy file="${webapp.path}/bin/i18n" todir="${webapp.path}/${plugin.name}"/>
        -->
        <!-- 产生可部署插件包 -->
        <jar jarfile="${webapp.path}/${plugin.name}.jar">
            <fileset dir="${webapp.path}/${plugin.name}" includes="**/**"/>
        </jar>    
    </target>    
    
    <!-- 生成没有Web资源的可部署插件包 -->
    <target name="java-plug-jar">
        <!-- 插件插件包相关lib、 web目录 -->
        <mkdir dir="${webapp.path}/${plugin.name}/lib"/>
 
        <!-- 复制java servlet的相关jar包到插件包的lib目录下 -->
        <copy file="${java.jar}" todir="${webapp.path}/${plugin.name}/lib"/>
 
        <!-- 将相关的图片、帮助文档、修改日志等文件复制到插件目录下 -->
        <copy todir="${webapp.path}/${plugin.name}">
            <fileset dir="${plugin.path}" includes="*.*"/>
        </copy>
        
        <!-- 产生可部署插件包 -->
        <jar jarfile="${webapp.path}/${plugin.name}.jar">
            <fileset dir="${webapp.path}/${plugin.name}" includes="**/**"/>
        </jar>    
    </target>
                    
    <!-- 清理生成的文件 -->
    <target name="clean">
        <delete file="${webapp.path}/${plugin.name}.jar"/>
        <delete dir="${webapp.path}/${plugin.name}"/>
        <delete dir="${webapp.path}/jsp-dist"/>
        <delete dir="${webapp.path}/java-dist"/>
    </target>
    
    <target name="all" depends="clean,jspc,compile"/>
 
    <target name="openfire-plugin" depends="jspc,java-jar"/>
 
    <target name="openfire-plugins" depends="all,java-jar,plug-jar"/>
    
    <target name="openfire-plugin-java" depends="clean,java-jar,java-plug-jar"/>
</project>

build.properties文件内容

#tomcat home
tomcat.home=D:/tomcat-5.0.28/tomcat-5.0.28
webapp.path=D:/Workspace/OpenfirePlugin
 
plugin.name=sample
plugin.path=D\:/Workspace/OpenfirePlugin/src/plugins/sample

注意：这里我没有编写编译java代码到class的步骤，我是直接使用MyEclipse自动编译的bin/class的。如果你没有用MyEclipse或Eclipse，那么你需要将src中的Java代码编译class。

这里需要配置tomcat的目录，我这里是5.0.28的版本。我用tomcat6有些问题，这里主要是用tomcat中的lib库，帮助我们编译jsp。还需要配置你当前工程的所在目录，也就是工程在Eclipse中的目录位置。最后你需要配置插件的名称和插件在工程中的所在目录，这个是在打包的时候，需要将其他的html、image、xml等资源导入的jar内。

因为这里的插件是不带jsp的，所以我们执行clean、java-jar、java-plugin-jar。也就是openfire-plugin-java这个命令即可。执行命令后，你可以看到工作空间的工程目录下多了目录和文件。见图：

java-dist目录里面的就是src/plugin/sample目录中的java代码打成的jar包。具体你可以用zip打开看看。

sample就是我们的插件目录，和sample.jar中的内容是一模一样的。

sample.jar就是将sample目录打成jar包。

5、 发布插件

发布插件有2种方式

第一种：直接将插件放置在openfire服务器的plugins目录下。我的是在：C:\Program Files\openfire\plugins目录。重起openfire后你可以看到控制台输出我们插件中输出的内容，并且在C:\Program Files\openfire\plugins目录中可以看到该目录下多了一个sample的目录（openfire可以自动解压jar包）。

当你在关闭服务器的瞬间，也会打印销毁插件的消息。

第二种：在openfire启动的情况下，访问http://localhost:9090/plugin-admin.jsp页面，点击页面下方的upload plugin完成插件上传操作。

插件按照成功后，访问http://localhost:9090/plugin-admin.jsp页面你就可以看到安装好的插件了。

至此，不带jsp页面的简单插件就编写部署成功了。

三、开发带jsp、PluginServlet的插件

有些插件是单纯的继承Plugin或Handler什么的，但有些是需要jsp页面和Servlet的。下面我们就来开发带jsp和servlet的插件。

在之前的目录下添加文件，目录结构如下：

1、 首先建立一个SampleServlet的文件，内容如下

package com.hoo.server.plugin;
 
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
/**
 * <b>function:</b> sample servlet
 * @author hoojo
 * @createDate 2013-3-4 下午04:15:20
 * @file SampleServlet.java
 * @package com.hoo.server.plugin
 * @project OpenfirePlugin
 * @blog http://blog.csdn.net/IBM_hoojo
 * @email [email protected]
 * @version 1.0
 */
public class SampleServlet extends HttpServlet {
    
    private static final long serialVersionUID = -5404916983906926869L;
 
    @Override
    public void init() throws ServletException {
        super.init();
    }
    
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        super.doGet(request, response);
        
        response.setContentType("text/plain");
        PrintWriter out = response.getWriter();
        System.out.println("请求SampleServlet GET Method");
        out.print("请求SampleServlet GET Method");
        out.flush();
    }
 
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        super.doPost(request, response);
        
        response.setContentType("text/plain");
        PrintWriter out = response.getWriter();
        System.out.println("请求SampleServlet GET Method");
        out.print("请求SampleServlet POST Method");
        out.flush();
    }
 
    @Override
    public void destroy() {
        super.destroy();
    }
}

2、 在当前插件根目录添加web目录，在目录下建立WEB-INF目录，添加web-custom.xml文件（文件名应该是固定的）。在里面配置我们的servlet。

<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>
    
    <servlet>
        <servlet-class>com.hoo.server.plugin.SampleServlet</servlet-class>
        <servlet-name>SampleServlet</servlet-name>
    </servlet>
    
    <servlet-mapping>
        <servlet-name>SampleServlet</servlet-name>
        <url-pattern>/servlet</url-pattern>
    </servlet-mapping>
</web-app>

当插件发布后你可以通过用：http://127.0.0.1:9090/plugins/sample/servlet 就可以访问到这个servlet了。但我发现我们只需用http://127.0.0.1:9090/plugins/sample也是可以访问到的。好像openfire会自动找到我们插件目录下的servlet配置。

注意：这里的http://127.0.0.1:9090/plugins/是固定的，至少plugins是固定的。所有的插件都在plugins目录下访问的。如果你想知道为什么，你可以看看openfire源码下的web.xml，具体目录路径在/openfire/src/web/WEB-INF/web.xml。里面有一个PluginServlet是过来plugin的配置的。

3、 在web目录下添加jsp文件，文件名是插件名称-自定义名称.jsp（建议规范命名）

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>hello world： 你好openfire</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <meta name="pageID" content="sample-service"/>
  </head>
  
  <body>
    <h3>hello world jsp!! <a href="/plugins/sample/servlet">SampleServlet</a></h3>
    <div class="jive-contentBoxHeader">jive-contentBoxHeader</div>
    <div class="jive-contentBox">jive-contentBox</div>
    
    <div class="jive-table">
        <table cellpadding="0" cellspacing="0" border="0" width="100%">
            <thead>
                <tr>
                    <th>&nbsp;sss</th>
                    <th nowrap>a</th>
                    <th nowrap>b</th>
                </tr>
            </thead>
            <tbody>
                <tr>
                    <td align="center">asdf</td>
                    <td align="center">asdf</td>
                    <td align="center">asdf</td>
                </tr>
                <tr class="jive-even">
                       <td align="center">asdf</td>
                    <td align="center">asdf</td>
                    <td align="center">asdf</td>
                </tr>
                <tr class="jive-odd">
                       <td align="center">asdf</td>
                    <td align="center">asdf</td>
                    <td align="center">asdf</td>
                </tr>
             </tbody>
        </table>
    </div>
  </body>
</html>

其中最重要的一点就是：<meta name="pageID" content="sample-service"/>这个pageID。这里的是固定的，后面的content对应我们plugin.xml的内容（等下看看plguin.xml的配置）。然后可以适当的看下里面table的 属性和样式，因为很多时候会在jsp中显示内容，且用table布局的。

4、 改下之前的plugin.xml的配置，配置组件在openfire 管理员控制台的哪个地方显示，以及显示的页面。

<?xml version="1.0" encoding="UTF-8"?>
<plugin>
    <!-- Main plugin class  这里是最重要滴，就是你的插件的全路径-->
    <class>com.hoo.server.plugin.SamplePlugin</class>
 
    <!-- Plugin meta-data -->
    <name>SimplePlugin</name>
    <description>This is the my sample plugin.</description>
    <author>hoojo</author>
 
    <version>1.0</version>
    <date>28/02/2013</date>
    <url>http://localhost:9090/openfire/plugins.jsp</url>
    <minServerVersion>3.4.1</minServerVersion>
    <licenseType>gpl</licenseType>
 
    <adminconsole>    
        <tab id="tab-server">
            <sidebar id="sidebar-server-settings">
                <item id="sample-service" name="Sample Service" url="sample-service.jsp"
                     description="Click is trigger sample plugin" />
            </sidebar>
        </tab>
    </adminconsole>
</plugin>

这里主要就是adminconsole这里面的配置。首先tab-server应该是在管理员控制台页面的服务器菜单中显示；sidebar中的的id配置固定这样写即可；item中的id（sample-service）对应的就是上面的sample-service.jsp的<meta name="pageID" content="sample-service"/>的content内容；item的url对应的是我们写的jsp页面；name是插件的菜单名称。也就是说在管理员控制台页面中的服务器菜单下增加一个sample service的菜单，打开的页面是sample-service.jsp页面。

5、 运行ant脚本，打包发布插件。在上一章节有完整ant脚本的，运行build.xml中的这个openfire-plugins命令即可打包。然后将打好包的sample.jar发布到openfire的plugins目录下即可。

打包后的jar插件目录结构如下：

启动openfire后，在openfire管理员控制台页面的服务器->服务器设置中就可以看到Sample Service插件了。

点击Sample Servlet就可以看到openfire控制台打印请求的文字信息。

ok，至此开发自己的openfire插件基本上就是这样的，网上这方面的资料很少，我也是官方的插件源码和网上提供的小部分资料才整出来的。本来在去年（2012）就应该发布这篇文章的，不料那个时候每天都很忙。加班、上线什么的，所以这篇文章才在今日发表。

下篇文章就是开发openfire的聊天记录插件，到时欢迎大家阅读。请随时关注我的动态哦！

如果你觉得本文不错，请点一下浏览器右下角的“顶”。谢谢！^_^

时间： 2024-09-29 00:17:32

跟我一步一步开发自己的Openfire插件的相关文章

一步一步学习Swift之(一)：关于swift与开发环境配置

一.什么是Swift? 1.Swift 是一种新的编程语言,用于编写 iOS 和 OS X 应用. 2.Swift 结合了 C 和 Objective-C 的优点并且不受 C 兼容性的限制. 3.Swift 采用安全的编程模式并添加了很多新特性,这将使编程更简单,更灵活,也更有趣. 4.Swift 是基于成熟而且倍受喜爱的 Cocoa 和 Cocoa Touch 框架,它的降临将重新定义软件开发. 5.Swift 是编写 iOS 和 OS X 应用的极佳手段,并将伴随着新的特性和功能持续演进.

windows phone开发第一步:搭建软件开发环境

windows phone开发第一步:搭建软件开发环境:http://www.cnblogs.com/hanjun/archive/2012/10/09/2716669.html

一步一步开发属于自己的SharePoint 2010工作流

一步一步开发属于自己的SharePoint 2010工作流 分类: sharepoint MOSS2013-03-17 08:26 376人阅读 评论(0) 收藏 举报 目录(?)[+] 从Sharepoint 2007开始,工作流作为一个真正的强有力的工具内置在SharePoint中.你可以通过设计工作流,从而在网站或应用程序中添加自定义逻辑,而且不需要编写任何代码!通过工作流实现业务流程自动化所需的各种功能,从发送通知到创建任务这么简单的事都可以通过工作流完成.还有的很多可能性,许多的功能有

C#WPF 语音开发教程 源代码下载 csdn tts（text to sound） 一步一步 教你制作语音软件 附图和源代码

C#WPF  语音开发教程  一步一步 教你制作语音软件 附图和源代码 效果展示 一 项目准备 1.vs2012开发平台 2.微软的语音软件库 下载:http://download.csdn.net/detail/wyx100/8431269 (含实例项目源代码) 二.开发目标 制作一个语音软件,可以朗读文字: 多个语音库:男音和女音.支持英文和中文朗读: 支持选择播放设备 支持朗读语速选择 支持音量选择 三 开发过程 1.新建WpfSpeechDemo工程 文件(vs开发平台左上角)----新

一步一步跟我学DeviceOne开发 - 仿微信应用(一，二，三)

这是一个系列的文档,长期目标是利用DeviceOne开发一些目前使用广泛的优质手机应用,我们会最大化的实现这些应用的每一个功能和细节,不只停留在简单的UI模仿和Demo阶段,而是一个基本可以使用的实际App. 在实现的过程中,会有很多困难,还会发现有一些功能目前缺乏组件支持而无法实现,也会碰见各种移动开发中都会碰到的常见技术问题.一步一步的操作和问题的解决可以让开发者直观的了解通过DeviceOne如何开发一个实际App,也可以了解移动开发本身的很多技术细节,可以让App开发者少走很多弯路. 这

一步一步开发呼叫中心

最近两个月,每天熬夜到凌晨5点,睡3个小时,继续奋战.少年,你这么拼,你未出生的女儿知道么?(其实我也不确定是不是女儿,由于个人最喜欢女儿,姑且当我那还有1个多月出来见老爸的宝贝是个女儿吧!) 唉,创业难,做苦逼程序员更难,做没有任何指导要一个人进入一个新的领域的程序员更难! 2014年做了好多事情,前两个月一直忙,也没有花时间来总结自己的得失,这两天公司终于没啥事了,来写下开发呼叫中心的心得体会. 事先声明: 1.本文为个人总结文章,非开源项目,核心的呼叫中心源码不会开放,总结的是开发思路 2

一步一步开发Game服务器（三）加载脚本和服务器热更新（二）完整版

上一篇文章我介绍了如果动态加载dll文件来更新程序 一步一步开发Game服务器(三)加载脚本和服务器热更新 可是在使用过程中,也许有很多会发现,动态加载dll其实不方便,应为需要预先编译代码为dll文件.便利性不是很高. 那么有么有办法能做到动态实时更新呢???? 官方提供了这两个对象,动态编译源文件. 提供对 C# 代码生成器和代码编译器的实例的访问. CSharpCodeProvider 提供一下方法加载源文件, // 基于包含在 System.CodeDom.CodeCompileUnit

一步一步构建手机WebApp开发——环境搭建篇

从2007年,乔布斯带来了第一代Iphone手机,整个移动互联网发生天翻地覆的变化,也同时证明了乔布斯的一句名言:“再一次改变世界”. 在当今的移动互联网,手机App居多,很多App对移动设备的要求也越来越高,当然,土豪就可以经常更新换代.我们这群屌丝只能望梅止渴.为了解决少部分由于硬件或者软件引起的问题,我们将App迁移到浏览器上,也就是人们常说的WebApp,WebApp相对与手机App客户端有以下优点: 1.免安装,一个浏览器就可以搞定. 2.不需要繁忙的迭代更新. 3.不需要担心存储不足

一步一步开发Game服务器（四）地图线程

时隔这么久 才再一次的回归正题继续讲解游戏服务器开发. 开始讲解前有一个问题需要修正.之前讲的线程和定时器线程的时候是分开的. 但是真正地图线程与之前的线程模型是有区别的. 为什么会有区别呢?一个地图肯定有执行线程,但是每一个地图都有不同的时间任务.比如检测玩家身上的buffer,检测玩家的状态值.这种情况下如何处理呢?很明显就需要定时器线程. 我的处理方式是创建一个线程的时候根据需求创建对应的 timerthread 直接上代码其他不BB 1 using System; 2 using Sys