精华内容
下载资源
问答
  • openfire插件

    2019-01-15 09:27:15
    openfire视频会议插件。 To install plugins,copy the .jar file into the plugins directory of your Openfire installation.
  • openfire插件开发(1)

    2019-04-12 01:27:13
    NULL 博文链接:https://zfms.iteye.com/blog/1702309
  • NULL 博文链接:https://beautyofprogram.iteye.com/blog/772281
  • Openfire插件开发实例

    2016-12-23 11:07:52
    目的:主要是为了监控Openfire各类message,然后对message body做进一步...局限:因为时间有限,本插件并没有对Openfire message协议进行扩展,都是基于原生的xml协议,因此后续开发还需要进行更加深入的二次开发操作。
  • openfire插件使用Demo

    2014-09-10 21:49:40
    openfire3.6.3插件开发方法说明: winxp/myeclipse6.5/jdk1.5&1.6/mysql5.0/openfire3.6.3 开发步骤:1. 布署openfire3.6.3源码(请参考openfire3.6.3导入eclipse项目实现方法)
  • maven构建openfire插件

    2020-04-30 08:31:23
    记录一次使用maven插件构建openfire插件的全部过程 因为项目需要, 故把openfire源码下载下来修改发布, 期间要使用自己编写的openfire插件, 最新版的openfire使用maven构建, 故插件的项目构建方式也使用了maven, ...

    记录一次使用maven插件构建openfire插件的全部过程

    因为项目需要, 故把openfire源码下载下来修改发布, 期间要使用自己编写的openfire插件, 最新版的openfire使用maven构建, 故插件的项目构建方式也使用了maven, openfire的插件目录结构非常特殊, 点我了解更多, 需要个性化 的maven配置才能生成可用的插件jar

    项目结构

    project/
      |- pom.xml
      |- plugin.xml      
      |- readme.html     
      |- changelog.html  
      |- logo_small.gif  
      |- logo_large.gif  
      |- src
        |- main
          |- java(source dir)
          |- web

    构建过程

    首先把src-main下的java设置成source root文件夹, 使下面的类可以引用jdk环境, 编写好代码之后, 直接编写pom文件, 用maven插件去定义生成好的jar包内部结构

    爬坑1: 与src平级的几个文件不能打进jar包, 因为顶级文件夹并不是resources文件夹
    
    解决1: 使用maven-resources插件, 指定resource位置, 与在jar里的位置, 
    也可以直接在build标签下使用resources标签声明, 这是maven的约定写法, 不过我还是声明了插件
    
    爬坑2: 仔细看openfire插件结构, 可以看到, 插件jar里面有个lib文件夹, lib下存放的jar才是真正java代码打包好的文件, 
    我一开始想着使用resources插件, 把打包好的jar重复放进jar里(相当于向自己里放了个自己), 后来证明是矛盾的, 而且是不好使的
    
    解决2: 使用ant插件, 定义最终的jar结构, 并且配置maven-jar, 只编译java类, 其余组织的工作交给ant插件做
    

    pom文件(附说明)

    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <!-- 父工程为openfire插件工程 -->
        <parent>
            <artifactId>plugins</artifactId>
            <groupId>org.igniterealtime.openfire</groupId>
            <version>4.4.2</version>
        </parent>
        <groupId>com.gomyck</groupId>
        <artifactId>openfire-plugin-gomyck-sendmessage</artifactId>
        <name>Openfire Plugin Gomyck Sendmessage</name>
        <description>
            消息插件
        </description>
    
        <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        </properties>
    
        <build>
            <!-- 初次打包的jar名称 -->
            <finalName>gomyck-sendMessage</finalName>
            <plugins>
                <!-- maven编译插件, 声明周期为compiler, 主要负责编译java类 -->
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.5.1</version>
                    <configuration>
                        <!-- 源代码开发版本 -->
                        <source>1.8</source>
                        <!-- 目标编译版本 -->
                        <target>1.8</target>
                        <!-- 编码方式 -->
                        <encoding>${project.build.sourceEncoding}</encoding>
                    </configuration>
                </plugin>
                <!-- maven 打jar包插件, 这个插件遇到的坑最多, 其遵循就近原则, 如果在configuration中写了配置, 
                那么其默认的配置都会不好使, 比如include, 如果用了, 那么只会编译include的类 -->
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-jar-plugin</artifactId>
                    <version>3.1.0</version>
                    <configuration>
                        <!-- 只在jar里放class文件, 如果不写这个, 那么resources插件生成的资源文件也会打进jar里, 如果写了这个,
                         resources插件只会在target-class文件夹下生成文件 -->
                        <includes>
                            <include>**/com/gomyck/**</include>
                        </includes>
                        <outputDirectory>${project.build.directory}</outputDirectory>
                    </configuration>
                </plugin>
    
                <!-- maven 资源插件, 这个插件主要把一些外部文件变成打包时的资源文件 -->
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-resources-plugin</artifactId>
                    <version>3.1.0</version>
                    <executions>
                        <execution>
                            <phase>install</phase>
                            <!-- resources 和 copy-resources, 如果是resources, 
                            则直接会在jar包里体现, 如果是copy-resources, 那还必须指定要copy的目标文件夹位置 -->
                            <goals>
                                <goal>resources</goal>
                            </goals>
                        </execution>
                    </executions>
                    <configuration>
                        <resources>
                            <resource>
                                <!-- 资源文件所在文件夹 -->
                                <directory>${project.basedir}</directory>
                                <!-- 是否使用文件过滤器 -->
                                <filtering>true</filtering>
                                <!-- 如果使用过滤器, 那么包含哪些文件 -->
                                <includes>
                                    <include>changelog.html</include>
                                    <include>logo_large.gif</include>
                                    <include>logo_small.gif</include>
                                    <include>plugin.xml</include>
                                    <include>readme.html</include>
                                </includes>
                            </resource>
    
                            <resource>
                                <directory>${project.basedir}/src/main/web</directory>
                                <!-- jar包目标位置, 下面的意思是会在jar的根目录下建立web文件夹, 
                                并且把src/main/web下的所有文件都copy进去 -->
                                <targetPath>web</targetPath>
                            </resource>
    
                        </resources>
                    </configuration>
                </plugin>
    
                <plugin>
                    <!-- ant插件, 这个最重要了, 以上三个插件只是能够零散的把文件编译并放在target文件夹下, 
                    我使用ant插件, 把文件整理起来, 并压缩到指定的jar里面 -->
                    <artifactId>maven-antrun-plugin</artifactId>
                    <version>1.3</version>
                    <executions>
                        <execution>
                            <!-- 调用阶段 -->
                            <phase>install</phase>
                            <goals>
                                <!-- 目标(命令) -->
                                <goal>run</goal>
                            </goals>
                            <configuration>
                                <tasks>
                                    <echo message="开始构建插件包..."></echo>
                                    <copy todir="${project.build.directory}/${project.build.finalName}-final/lib" overwrite="true" file="${project.build.directory}/${project.build.finalName}.jar"></copy>
                                    <copydir dest="${project.build.directory}/${project.build.finalName}-final/" src="${project.build.directory}/classes/" excludes="org/**"></copydir>
                                    <jar basedir="${project.build.directory}/${project.build.finalName}-final/" destfile="${project.build.directory}/${project.build.finalName}-final.jar"></jar>
                                    <delete dir="${project.build.directory}/${project.build.finalName}-final/"></delete>
                                </tasks>
                            </configuration>
                        </execution>
                    </executions>
                </plugin>
    
            </plugins>
        </build>
    </project>

    ant文档地址(所有的ant构建命令可在此查看)

    点击前往

    个人博客

    点击前往
    展开全文
  • openfire插件Demo

    2013-10-19 16:58:34
    openfire插件Demo,请运行build.xml生成插件。请结合TOMCAT5使用
  • openfire 插件开发

    2019-04-23 01:11:28
    NULL 博文链接:https://zxs19861202.iteye.com/blog/2095407
  • openfire插件开发(plugin sevlet)入门 原创 2014年05月13日 21:50:38 标签:openfire插件 /servlert插件 2480 近来几天为了写一个openfire的小插件可谓脑袋都大了。。。自己又是...

    openfire插件开发(plugin sevlet)入门

    原创  2014年05月13日 21:50:38

    近来几天为了写一个openfire的小插件可谓脑袋都大了。。。自己又是初学小菜鸟一个,学习过程算是非常的磕磕绊绊。这里记录下来仅供后来的同学参考,也少走些弯路。勤能补拙,期望大家多多支持,共同学习,共同进步。


    1.plugin插件开发

    网上关于openfire插件开发的有很多,其中jooho大大的《跟我一步一步开发自己的openfire插件》很是受欢迎,我这里也是参考他的。不过相对于他的《 跟我一步一步开发自己的Openfire插件》相对于我这样的小白还是有点费解的,所以这里我就更简单通俗的再讲解一遍,在助人为乐的同时也能加深学习。

    本人用的是myeclipse,其他开发工具类同。

    1.1简单插件入门(简单plugin结构)

    在结构方面我最初也是很头疼,给那么多图反而更容易把人搞混淆。我们还是用文字加配图说明吧。

    新建一个 java project ,这里命名为 test_plugin。(new -> java project -> finish)然后把src删除或重命名为 src/plugins/test/src/java (即与openfire原生插件保持一致)。若是删除src的话,就新建 Source Folder命名为 src/plugins/test/src/java (new ->  Source Folder )。然后项目目录下就会自动生成对应的 src文件夹及层级结构。

       

    同样,在工程项目中新建文件夹(new ->folder)命名 build ,lib .其中build下边新建 build.properties 和 build.xml文件,用以ant编译生成插件。llib文件存放openfire等jar库。这里将openfir.jar + sevlet.jar拷贝至lib目录并add to buid path.

    (servlet其实可以不用,仅导入openfire.jar即可)

    1.2 build文件

    build文件用于编译和打包,很多像我这样的小白基本不会用代码打包编译。网上有推荐利用源码包里边的build来编译打包,这也是一种方法,这里我使用的是jooho大大写好的build文件。我稍微做了些修改。贴上两个文件源码

    uild.properties

    [html]  view plain  copy
    1. tomcat.home=D:/Program Files/tomcat-5.0.28  
    2. # If you want to build a plugin, please set the value to the plugin name.  
    3. # Note:The plugin name must is the same as the plugins folder.  
    4. plugin.name=test  
    (tomcat_home是你自己的tomcat安装/解压路径,plugin name是插件名)

    build.xml

    [html]  view plain  copy
    1. <project name="Webapp Precompilation" default="openfire-plugins" basedir=".">  
    2.       
    3.     <!-- 全局变量设置 -->  
    4.     <property file="build.properties" />  
    5.       
    6.     <!-- 插件源码位置 -->  
    7.     <property name="plugin.path" value="../src/plugins/${plugin.name}/src" />  
    8.       
    9.     <!-- web应用输出目录 -->  
    10.     <property name="webapp.output.path" value="../src/plugins/${plugin.name}/bin" />  
    11.       
    12.     <!-- java servlet相关文件编译jar存放位置 -->  
    13.     <property name="java.jar.dir" value="${webapp.output.path}/java-dist"/>  
    14.       
    15.     <!-- jsp servlet编译后jar存放位置 -->  
    16.     <property name="jsp.jar.dir" value="${webapp.output.path}/jsp-dist/lib"/>  
    17.   
    18.     <!-- 定义java servlet编译打包的Jar包名称 -->  
    19.     <property name="java.jar" value="${java.jar.dir}/plugin-${plugin.name}.jar"/>  
    20.       
    21.     <!-- 定义jsp servlet编译打包的Jar包名称 -->  
    22.     <property name="jsp.jar" value="${jsp.jar.dir}/plugin-${plugin.name}-jsp.jar"/>  
    23.   
    24.     <!-- jsp servlet配置到web.xml中 -->  
    25.     <property name="plugin.web.xml" value="${webapp.output.path}/jsp-dist/web.xml"/>  
    26.   
    27.     <!-- 编译jsp 并生成相关jar、xml文件 -->  
    28.     <target name="jspc">  
    29.   
    30.         <taskdef classname="org.apache.jasper.JspC" name="jasper2">  
    31.             <classpath id="jspc.classpath">  
    32.                 <pathelement location="${java.home}/../lib/tools.jar" />  
    33.                 <fileset dir="${tomcat.home}/bin">  
    34.                     <include name="*.jar" />  
    35.                 </fileset>  
    36.                 <fileset dir="${tomcat.home}/server/lib">  
    37.                     <include name="*.jar" />  
    38.                 </fileset>  
    39.                 <fileset dir="${tomcat.home}/common/lib">  
    40.                     <include name="*.jar" />  
    41.                 </fileset>  
    42.                 <!--  
    43.                 <fileset dir="D:/Workspace/openfire/build/lib">  
    44.                     <include name="**/*.jar" />  
    45.                 </fileset-->  
    46.             </classpath>  
    47.         </taskdef>  
    48.   
    49.         <!-- 编译jsp -> servlet class -->  
    50.         <jasper2 javaEncoding="UTF-8" validateXml="false"  
    51.             uriroot="${plugin.path}/web"  
    52.             outputDir="${webapp.output.path}/jsp-dist/src"  
    53.             package="com.qiao.univer.blog.plugin.${plugin.name}" />  
    54.   
    55.         <!-- 编译后的servlet class 配置到web.xml文件中 -->  
    56.         <jasper2  
    57.             validateXml="false"  
    58.             uriroot="${plugin.path}/web"  
    59.             outputDir="${webapp.output.path}/jsp-dist/src"  
    60.             package="com.qiao.univer.blog.plugin.${plugin.name}"  
    61.             webXml="${plugin.web.xml}"/>  
    62.     </target>  
    63.   
    64.     <!-- 编译jsp 并将其打jar包 -->  
    65.     <target name="compile">  
    66.   
    67.         <mkdir dir="${webapp.output.path}/jsp-dist/classes" />  
    68.         <mkdir dir="${webapp.output.path}/jsp-dist/lib" />  
    69.         <mkdir dir="${webapp.output.path}/jsp-dist/src" />  
    70.   
    71.         <javac destdir="${webapp.output.path}/jsp-dist/classes" optimize="off"  
    72.             encoding="UTF-8" debug="on" failonerror="false"  
    73.             srcdir="${webapp.output.path}/jsp-dist/src" excludes="**/*.smap">  
    74.             <classpath>  
    75.                 <pathelement location="${webapp.output.path}/jsp-dist/classes" />  
    76.                 <fileset dir="${webapp.output.path}/jsp-dist/lib">  
    77.                     <include name="*.jar" />  
    78.                 </fileset>  
    79.                 <pathelement location="${tomcat.home}/common/classes" />  
    80.                 <fileset dir="${tomcat.home}/common/lib">  
    81.                     <include name="*.jar" />  
    82.                 </fileset>  
    83.                 <pathelement location="${tomcat.home}/shared/classes" />  
    84.                 <fileset dir="${tomcat.home}/shared/lib">  
    85.                     <include name="*.jar" />  
    86.                 </fileset>  
    87.                 <fileset dir="${tomcat.home}/bin">  
    88.                     <include name="*.jar" />  
    89.                 </fileset>  
    90.             </classpath>  
    91.             <include name="**" />  
    92.             <exclude name="tags/**" />  
    93.         </javac>  
    94.   
    95.         <jar jarfile="${jsp.jar}" basedir="${webapp.output.path}/jsp-dist/classes" />  
    96.     </target>  
    97.   
    98.     <!-- 将java servlet打包成jar -->  
    99.     <target name="java-jar">  
    100.         <mkdir dir="${java.jar.dir}"/>  
    101.         <jar jarfile="${java.jar}">  
    102.             <fileset dir="../bin" includes="**/*.class"/>  
    103.         </jar>  
    104.     </target>  
    105.   
    106.     <!-- 生成可部署的插件包 -->  
    107.     <target name="plug-jar">  
    108.         <!-- 插件插件包相关lib、 web目录 -->  
    109.         <mkdir dir="${webapp.output.path}/${plugin.name}/lib"/>  
    110.         <mkdir dir="${webapp.output.path}/${plugin.name}/web/WEB-INF"/>  
    111.   
    112.         <!-- 复制jsp servlet的jar和java servlet的相关jar包到插件包的lib目录下 -->  
    113.         <copy file="${java.jar}" todir="${webapp.output.path}/${plugin.name}/lib"/>  
    114.         <copy file="${jsp.jar}" todir="${webapp.output.path}/${plugin.name}/lib"/>  
    115.   
    116.         <!-- 将相关的图片、帮助文档、修改日志等文件复制到插件目录下 -->  
    117.         <copy todir="${webapp.output.path}/${plugin.name}">  
    118.             <fileset dir="${plugin.path}" includes="*.*"/>  
    119.         </copy>  
    120.         <copy todir="${webapp.output.path}/${plugin.name}/web">  
    121.             <fileset dir="${plugin.path}/web">  
    122.                 <include name="*"/>  
    123.                 <include name="**/*.*"/>  
    124.                 <exclude name="**/*.xml"/>  
    125.                 <exclude name="**/*.jsp"/>  
    126.             </fileset>  
    127.         </copy>  
    128.         <!-- jsp servlet的web复制到插件目录下 -->  
    129.         <copy file="${plugin.web.xml}" todir="${webapp.output.path}/${plugin.name}/web/WEB-INF"/>  
    130.         <copy todir="${webapp.output.path}/${plugin.name}/web">  
    131.             <fileset dir="${plugin.path}/web" includes="**/*.xml"/>  
    132.         </copy>  
    133.         <!-- 将国际化相关资源文件复制到插件目录下   
    134.         <copy file="${webapp.output.path}/bin/i18n" todir="${webapp.output.path}/${plugin.name}"/>  
    135.         -->  
    136.         <!-- 产生可部署插件包 -->  
    137.         <jar jarfile="${webapp.output.path}/${plugin.name}.jar">  
    138.             <fileset dir="${webapp.output.path}/${plugin.name}" includes="**/**"/>  
    139.         </jar>  
    140.     </target>  
    141.   
    142.     <!-- 生成没有Web资源的可部署插件包 -->  
    143.     <target name="java-plug-jar">  
    144.         <!-- 插件插件包相关lib、 web目录 -->  
    145.         <mkdir dir="${webapp.output.path}/${plugin.name}/lib"/>  
    146.   
    147.         <!-- 复制java servlet的相关jar包到插件包的lib目录下 -->  
    148.         <copy file="${java.jar}" todir="${webapp.output.path}/${plugin.name}/lib"/>  
    149.   
    150.         <!-- 将相关的图片、帮助文档、修改日志等文件复制到插件目录下 -->  
    151.         <copy todir="${webapp.output.path}/${plugin.name}">  
    152.             <fileset dir="${plugin.path}" includes="*.*"/>  
    153.         </copy>  
    154.   
    155.         <!-- 产生可部署插件包 -->  
    156.         <jar jarfile="${webapp.output.path}/${plugin.name}.jar">  
    157.             <fileset dir="${webapp.output.path}/${plugin.name}" includes="**/**"/>  
    158.         </jar>  
    159.     </target>  
    160.   
    161.     <!-- 清理生成的文件 -->  
    162.     <target name="clean">  
    163.         <delete file="${webapp.output.path}/${plugin.name}.jar"/>  
    164.         <delete dir="${webapp.output.path}/${plugin.name}"/>  
    165.         <delete dir="${webapp.output.path}/jsp-dist"/>  
    166.         <delete dir="${webapp.output.path}/java-dist"/>  
    167.     </target>  
    168.   
    169.     <target name="all" depends="clean,jspc,compile"/>  
    170.   
    171.     <target name="openfire-plugin" depends="jspc,java-jar"/>  
    172.   
    173.     <target name="openfire-plugins" depends="all,java-jar,plug-jar"/>  
    174.   
    175.     <target name="openfire-plugin-java" depends="clean,java-jar,java-plug-jar"/>  
    176. </project>  
    (这里有两点请注意修改
    这两个地方请修改为你新建的包名。例如我的 com.qiao.univer.blogplugin)
    此处不修改对 1.1简单plugin并没有影响,但对于复杂插件开发如servlet等功能添加将导致打包失败。

    1.3 其他文件结构

    在source folder下新建包(例 com.qiao.test.plugin),此包即为上边要修改的地方。

    新建TestPlugin 类并实现Plugin接口 中的 init 和 destroy方法:

    TestPlugin .java

    [java]  view plain  copy
    1. import java.io.File;  
    2.   
    3. import org.jivesoftware.openfire.XMPPServer;  
    4. import org.jivesoftware.openfire.container.Plugin;  
    5. import org.jivesoftware.openfire.container.PluginManager;  
    6.   
    7. public class TestPlugin implements Plugin {  
    8.   
    9.     private XMPPServer server;  
    10.   
    11.     @Override  
    12.     public void initializePlugin(PluginManager manager, File pluginDirectory) {  
    13.         server = XMPPServer.getInstance();  
    14.         System.out.println("qiao init Plugin!");  
    15.         System.out.println(server.getServerInfo());  
    16.     }  
    17.   
    18.     @Override  
    19.     public void destroyPlugin() {  
    20.         System.out.println("qiao destroy Plugin!");  
    21.     }  
    22. }  

    在自动生成的src文件夹层级结构最底层src目录下添加 

    changelog.htmllogo_small.giflogo_large.gif readme.html 和plugin.xml文件,其中前面是个可以从openfire源码中拷贝

    changelog.html是修改日志;logo_small.gif是插件图标;plugin.xml是我们配置插件的文件,这个很重要。

    配置 plugin.xml

    [html]  view plain  copy
    1. <?xml version="1.0" encoding="UTF-8"?>  
    2. <plugin>  
    3.     <!-- Main plugin class  这里是最重要滴,就是你的插件的全路径-->  
    4.     <class>com.qiao.test.plugin.TestPlugin</class>  
    5.    
    6.     <!-- Plugin meta-data -->  
    7.     <name>TestPlugin</name>  
    8.     <description>This is testplugin.</description>  
    9.     <author>qiao</author>  
    10.    
    11.     <version>1.0</version>  
    12.     <date>10/05/20134</date>  
    13.     <url>http://localhost:9090/openfire/plugins.jsp</url>  
    14.     <minServerVersion>3.4.1</minServerVersion>  
    15.     <licenseType>gpl</licenseType>  
    16.    
    17.     <adminconsole>     
    18.     </adminconsole>  
    19. </plugin>  
    注意上面的class的配置,那个配置是最为重要的,配置的是插件的全路径;name是插件的名称,安装后的插件名称;author是插件作者;lincenseType是协议;adminconsole是配置插件关联的页面的,这里用不上

    至此,整个框架大概就是这样:



     编写ant命令,打可部署jar包。如果你不懂ant命令也没关系,你总知道java的基本常用的dos命令。只不过ant就是将dos转换成一个可重复多次调用的命令行。我们这里就是用上边的build.xml利用ant来编译和打包。

    以下是jooho大大的话,小白可以略过。

    注意:这里我没有编写编译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这个命令即可。执行命令后,你可以看到工作空间的工程目录下多了目录和文件。

    1.4 插件打包部署


    我们右键点击build.xml选择 run as -> ant build..


    一个openfire的完美开发实例


    选择openfire-plugin-java


    一个openfire的完美开发实例


    等待打包完成

    一个openfire的完美开发实例

    打包完成后刷新工程项目,会看到多出来个bin文件夹


    打包成功的test.jar部署到openfire服务器,部署有两种方法:

    1.直接拷贝至openfire安装目录下的plugins的文件夹内,自启动后它会自动解压

    一个openfire的完美开发实例  

    2.登录openfire管理界面,选择插件,上传

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

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



    测试插件。启动openfire,就可以看到插件的运行结果如下:



    2.含有servlet和JSP的插件开发

    2.1 serlet开发及配置

     新建一个TestServlet.java 继承HttpServlet

    TestServlet.java

    [java]  view plain  copy
    1. import java.io.IOException;  
    2. import java.io.PrintWriter;  
    3. import javax.servlet.ServletException;  
    4. import javax.servlet.http.HttpServlet;  
    5. import javax.servlet.http.HttpServletRequest;  
    6. import javax.servlet.http.HttpServletResponse;  
    7.   
    8. import org.jivesoftware.admin.AuthCheckFilter;  
    9.   
    10. public class TestServlet extends HttpServlet {  
    11.   
    12.     private static final long serialVersionUID = 1L;  
    13.     private static final String SERVICE_NAME = "test/*";  
    14.   
    15.     @Override  
    16.     public void init() throws ServletException {  
    17.         super.init();  
    18.         AuthCheckFilter.addExclude(SERVICE_NAME);  
    19.     }  
    20.   
    21.     @Override  
    22.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {  
    23.           
    24.         response.setContentType("text/plain");  
    25.         PrintWriter out = response.getWriter();  
    26.         System.out.println("请求TestServlet GET Method");  
    27.         out.print("请求TestServlet GET Method");  
    28.         out.flush();  
    29.     }  
    30.    
    31.     @Override  
    32.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {  
    33.           
    34.         response.setContentType("text/plain");  
    35.         PrintWriter out = response.getWriter();  
    36.         System.out.println("请求TestServlet GET Method");  
    37.         out.print("请求TestServlet POST Method");  
    38.         out.flush();  
    39.     }  
    40.   
    41.     @Override  
    42.     public void destroy() {  
    43.         super.destroy();  
    44.         AuthCheckFilter.removeExclude(SERVICE_NAME);  
    45.     }  
    46. }  

    其中 AuthCheckFilter.addExclude(SERVICE_NAME); 是为了避免登录验证,如果没有这一段代码。每次访问TestServelt都会出现跳转到登录界面的情况。

    在项目目录src层次结构最底层的src添加web目录,在目录下建立WEB-INF目录,添加web-custom.xml文件(文件名应该是固定的)。在里面配置我们的servlet。

    web-custom.xml

    [html]  view plain  copy
    1. <?xml version="1.0" encoding="ISO-8859-1"?>  
    2. <!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">  
    3. <web-app>  
    4.       
    5.     <servlet>  
    6.         <servlet-class>com.qiao.test.plugin.servlet.TestServlet</servlet-class>  
    7.         <servlet-name>TestServlet</servlet-name>  
    8.     </servlet>  
    9.       
    10.     <servlet-mapping>  
    11.         <servlet-name>TestServlet</servlet-name>  
    12.         <url-pattern>/servlet</url-pattern>  
    13.     </servlet-mapping>  
    14. </web-app>  


    2.2 Jsp开发及配置

    在web目录下添加jsp文件。例 test-demo.jsp

    test-demo.jsp

    [html]  view plain  copy
    1. <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>  
    2. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">  
    3. <html>  
    4.   <head>  
    5.     <title>test service: 你好openfire</title>  
    6.     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">  
    7.     <meta name="pageID" content="test-service"/>  
    8.   </head>  
    9.     
    10.   <body>  
    11.     <h3>test server jsp!! <a href="/plugins/test/servlet">TestServlet</a></h3>  
    12.     <div class="jive-contentBoxHeader">jive-contentBoxHeader</div>  
    13.     <div class="jive-contentBox">jive-contentBox</div>  
    14.       
    15.     <div class="jive-table">  
    16.         <table cellpadding="0" cellspacing="0" border="0" width="100%">  
    17.             <thead>  
    18.                 <tr>  
    19.                     <th> sss</th>  
    20.                     <th nowrap>a</th>  
    21.                     <th nowrap>b</th>  
    22.                 </tr>  
    23.             </thead>  
    24.             <tbody>  
    25.                 <tr>  
    26.                     <td align="center">asdf</td>  
    27.                     <td align="center">asdf</td>  
    28.                     <td align="center">asdf</td>  
    29.                 </tr>  
    30.                 <tr class="jive-even">  
    31.                        <td align="center">asdf</td>  
    32.                     <td align="center">asdf</td>  
    33.                     <td align="center">asdf</td>  
    34.                 </tr>  
    35.                 <tr class="jive-odd">  
    36.                        <td align="center">asdf</td>  
    37.                     <td align="center">asdf</td>  
    38.                     <td align="center">asdf</td>  
    39.                 </tr>  
    40.              </tbody>  
    41.         </table>  
    42.     </div>  
    43.   </body>  
    44. </html>  

    其中最重要的一点就是:<meta name="pageID" content="sample-service"/>这个pageID。这里的是固定的,后面的content对应我们plugin.xml的内容(等下看看plguin.xml的配置)。然后可以适当的看下里面table的 属性和样式,因为很多时候会在jsp中显示内容,且用table布局的。
    改下之前的plugin.xml的配置,配置组件在openfire 管理员控制台的哪个地方显示,以及显示的页面。

    plugin.xml

    [html]  view plain  copy
    1. <?xml version="1.0" encoding="UTF-8"?>  
    2. <plugin>  
    3.     <!-- Main plugin class  这里是最重要滴,就是你的插件的全路径-->  
    4.     <class>com.qiao.test.plugin.TestPlugin</class>  
    5.    
    6.     <!-- Plugin meta-data -->  
    7.     <name>TestPlugin</name>  
    8.     <description>This is testplugin.</description>  
    9.     <author>qiao</author>  
    10.    
    11.     <version>1.0</version>  
    12.     <date>10/05/20134</date>  
    13.     <url>http://localhost:9090/openfire/plugins.jsp</url>  
    14.     <minServerVersion>3.4.1</minServerVersion>  
    15.     <licenseType>gpl</licenseType>  
    16.    
    17.     <adminconsole>     
    18.         <tab id="tab-server">  
    19.             <sidebar id="sidebar-server-settings">  
    20.                 <item id="test-service" name="Test Service" url="test-demo.jsp"  
    21.                      description="Click is trigger blog plugin" />  
    22.             </sidebar>  
    23.         </tab>  
    24.     </adminconsole>  
    25. </plugin>  

    注意,这里是jsp里边的 pageID


    2.3 运行ant,发布插件

    这里选中openfire-plugins(default)命令打包,然后发布test.jar
    注意:若最初没有修改build.xml中的包名(com.***略),这里会报错。打包失败



    将test.jar发布之后,启动openfire,在openfire管理员控制台页面的服务器->服务器设置中就可以看到Test Service插件了。

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

    3.Servlet拓展问题及解决

    3.1.servlet登录验证问题

    在没有特殊要求的情况下,我们希望直接调用sevlet却常常会跳转到另外一个界面,即管理控制台登录界面。

    那怎么单独对自己插件的url进行排除呢?接着往下看!

    有两种方法:修改openfire的web.xml或使用AuthCheckFilter.addExclude方法其中一种即可

    1)修改openfire的web.xml

    这个web.xml出现在openfire的源码很多地方,了解正确的配置方法很重要。下面展示不同路径下的web.xml修改说明,取其一即可。

    a. 修改/openfire_src/src/web/WEB-INF/web.xml,修改完后,记得还要用ant编译一次并重启才能生效。

    b. 修改/openfire_src/target/openfire/plugins/admin/webapp/WEB-INF/web.xml

    修改完后,直接重启即可生效,本方法同样适用于安装版的openfire

    [html]  view plain copy
    1. <filter>  
    2.     <filter-name>AuthCheck</filter-name>  
    3.     <filter-class>org.jivesoftware.admin.AuthCheckFilter</filter-class>  
    4.     <init-param>  
    5.         <param-name>excludes</param-name>  
    6.         <param-value>  
    7.             popplugin/*,login.jsp,index.jsp?logout=true,setup/index.jsp,setup/setup-*,.gif,.png,error-serverdown.jsp,setup/clearspace-integration-prelogin.jsp  
    8.         </param-value>  
    9.     </init-param>  
    10. </filter>  


     url的匹配规则比较复杂,有兴趣的同学可以去看AuthCheckFilter类源码,如果要测试自己的pattern对不对,可以使用org.jivesoftware.admin.AuthCheckFilterTest类执行JUnitTest试试,如自己加上一段:

    [java]  view plain copy
    1. assertTrue(AuthCheckFilter.testURLPassesExclude("popplugin/sendmessage""popplugin*"));  
    2. assertTrue(AuthCheckFilter.testURLPassesExclude("popplugin/sendmessage""popplugin/sendmessage"));  

     

    2)使用AuthCheckFilter.addExclude方法

    调用该方法和配置web.xml的效果是完全一样的,个人建议用此方法,因为本方法绿色安全、无污染,不修改和破坏原生openfire代码。

    这个方法可以在servlet的init方法或plugin的initializePlugin方法中调用。

    个人建议在servlet的init方法中调用,因为servlet的init方法比plugin的initializePlugin方法更早初始化,这个问题在“插件初始化顺序”会讲到。

    使用完后记得removeExclude一下,有始有终嘛。

    [java]  view plain copy
    1. @Override  
    2. public void init() throws ServletException  
    3. {  
    4.     System.out.println("UserMgrServlet init....");  
    5.     AuthCheckFilter.addExclude("popplugin/usermgr*");  
    6.     AuthCheckFilter.addExclude("popplugin/usermgr/*");  
    7. }  
    8.   
    9. @Override  
    10. public void destroy()  
    11. {  
    12.     System.out.println("UserMgrServlet destroy....");  
    13.     // Release the excluded URL  
    14.     AuthCheckFilter.removeExclude("popplugin/usermgr*");  
    15.     AuthCheckFilter.removeExclude("popplugin/usermgr/*");  
    16. }  


     注意:这种方式仅限于servlet的访问,如果访问插件的jsp/html页面,页面会报NullPointException异常,解决办法见下面的说明

    3.2.servlet仍然需要登录验证或者报NullPointException空指针异常

    有时候在添加 AuthCheckFilter.addExclude()后虽然没有跳转到登录验证了,但是若果没有登录过(session记录下管理控制台验证),会出现空指针现象:

    异常:
    java.lang.NullPointerException
    	at org.jivesoftware.openfire.admin.decorators.main_jsp._jspService(main_jsp.java:195)
    	at org.apache.jasper.runtime.HttpJspBase.service(HttpJspBase.java:97)
    	at javax.servlet.http.HttpServlet.service(HttpServlet.java:820)
    	at org.eclipse.jetty.servlet.ServletHolder.handle(ServletHolder.java:547)
    	at org.eclipse.jetty.servlet.ServletHandler.doHandle(ServletHandler.java:480)
    	at org.eclipse.jetty.server.handler.ScopedHandler.handle(ScopedHandler.java:119)
    	at org.eclipse.jetty.security.SecurityHandler.handle(SecurityHandler.java:520)
    	at org.eclipse.jetty.server.session.SessionHandler.doHandle(SessionHandler.java:227)
    	at org.eclipse.jetty.server.handler.ContextHandler.doHandle(ContextHandler.java:941)
    	at org.eclipse.jetty.servlet.ServletHandler.doScope(ServletHandler.java:409)
    	at org.eclipse.jetty.server.session.SessionHandler.doScope(SessionHandler.java:186)
    	at org.eclipse.jetty.server.handler.ContextHandler.doScope(ContextHandler.java:875)
    	at org.eclipse.jetty.server.handler.ScopedHandler.handle(ScopedHandler.java:117)
    	at org.eclipse.jetty.server.Dispatcher.include(Dispatcher.java:195)
    	at com.opensymphony.module.sitemesh.filter.PageFilter.applyDecorator(PageFilter.java:156)
    	at com.opensymphony.module.sitemesh.filter.PageFilter.doFilter(PageFilter.java:59)
    	at org.eclipse.jetty.servlet.ServletHandler$CachedChain.doFilter(ServletHandler.java:1330)
    	at org.eclipse.jetty.servlet.ServletHandler.doHandle(ServletHandler.java:478)
    	at org.eclipse.jetty.server.handler.ScopedHandler.handle(ScopedHandler.java:119)
    	at org.eclipse.jetty.security.SecurityHandler.handle(SecurityHandler.java:520)
    	at org.eclipse.jetty.server.session.SessionHandler.doHandle(SessionHandler.java:227)
    	at org.eclipse.jetty.server.handler.ContextHandler.doHandle(ContextHandler.java:941)
    	at org.eclipse.jetty.servlet.ServletHandler.doScope(ServletHandler.java:409)
    	at org.eclipse.jetty.server.session.SessionHandler.doScope(SessionHandler.java:186)
    	at org.eclipse.jetty.server.handler.ContextHandler.doScope(ContextHandler.java:875)
    	at org.eclipse.jetty.server.handler.ScopedHandler.handle(ScopedHandler.java:117)
    	at org.eclipse.jetty.server.handler.ContextHandlerCollection.handle(ContextHandlerCollection.java:250)
    	at org.eclipse.jetty.server.handler.HandlerCollection.handle(HandlerCollection.java:149)
    	at org.eclipse.jetty.server.handler.HandlerWrapper.handle(HandlerWrapper.java:110)
    	at org.eclipse.jetty.server.Server.handle(Server.java:349)
    	at org.eclipse.jetty.server.HttpConnection.handleRequest(HttpConnection.java:441)
    	at org.eclipse.jetty.server.HttpConnection$RequestHandler.headerComplete(HttpConnection.java:919)
    	at org.eclipse.jetty.http.HttpParser.parseNext(HttpParser.java:582)
    	at org.eclipse.jetty.http.HttpParser.parseAvailable(HttpParser.java:218)
    	at org.eclipse.jetty.server.AsyncHttpConnection.handle(AsyncHttpConnection.java:51)
    	at org.eclipse.jetty.io.nio.SelectChannelEndPoint.handle(SelectChannelEndPoint.java:586)
    	at org.eclipse.jetty.io.nio.SelectChannelEndPoint$1.run(SelectChannelEndPoint.java:44)
    	at org.eclipse.jetty.util.thread.QueuedThreadPool.runJob(QueuedThreadPool.java:598)
    	at org.eclipse.jetty.util.thread.QueuedThreadPool$3.run(QueuedThreadPool.java:533)
    	at java.lang.Thread.run(Unknown Source)

    而如果我们先在管理控制台登录一次就可以正常跳转了,这又怎么解决呢?!


    还有一种情况,我们发现在单纯使用servlet作为服务接口提供数据时候,openfire会莫名地加上它原有的布局及样式,而我们仅仅只需要 servlet的 writer 去 out.print()来respons回应数据,这又该如何解决呢?


    在多方查阅资料无果后,恨不得自己另写个服务器端的时候,终于找到了解决方案:

    插件的页面不使用openfire控制台的页面框架

    安装版的openfire的话,修改/openfire/plugins/admin/webapp/WEB-INF/decorators.xml文件

    源代码版的,要修改/openfire_src/src/web/WEB-INF/decorators.xml文件

    示例:

    [html]  view plain copy
    1. <excludes>  
    2.     <pattern>/plugins/test/*</pattern>  
    3.     <pattern>/setup/setup-completed.jsp*</pattern>  
    4.     <pattern>/setup/setup-ldap-server_test.jsp*</pattern>  
    5.     <pattern>/setup/setup-ldap-user_test.jsp*</pattern>  
    6.     <pattern>/setup/setup-ldap-group_test.jsp*</pattern>  
    7.     <pattern>/setup/setup-clearspace-integration_test.jsp*</pattern>  
    8.     <pattern>/setup/setup-admin-settings_test.jsp*</pattern>  
    9.     <pattern>/login.jsp*</pattern>  
    10.     <pattern>/plugin-icon.jsp*</pattern>  
    11.     <pattern>/js/jscalendar/i18n.jsp*</pattern>  
    12. </excludes>  

    这样,插件popplugin目录下的所有路径的jsp页面及js,css等,都能被自由的访问了。

    至此,海阔天空任鸟飞了。。


    感谢各位认真努力的童鞋看完这篇博文,同小白我一起了解学习了openfire插件的全过程。文中参考借鉴和挪用了不少大大的文字说明及图片,就不一一感谢了。希望看了这篇文章有收获的童鞋能给支持下。
    最后附上今天开发的插件示例源码:

    展开全文
  • 修改源代码2开发openfire插件从可扩展性上考虑自然是开发插件是上策只有插件无法实现时候才会选择修改源代码 下面就个人经验说明一下如何开发openfire插件 环境基础 要有一个配置好的openfire开发环境这个网络上有...
  • b9:B9 Openfire插件-源码

    2021-05-13 02:09:03
    B9 Openfire插件 B9是Openfire管理机器人。 它允许您使用简单的消息直接在XMPP客户端中更改Openfire配置。 基本用法 只需将命令发送到即可接收请求的信息或更改服务器配置。 有关更多信息,请参见控制台管理器上的...
  • openfire插件开发.pdf

    2021-09-27 13:16:29
    openfire插件开发.pdf
  • 跟我一步一步开发自己的Openfire插件 这篇是简单插件开发,下篇聊天记录插件。 开发环境: System:Windows WebBrowser:IE6+、Firefox3+ JavaEE Server:tomcat5.0.2.8、tomcat6 IDE:eclipse、MyEclipse...

    跟我一步一步开发自己的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:hoojo_@126.com

    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源码目录是这样的

    clip_image002

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

    clip_image004

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

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

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

    clip_image006

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

    3、 了解openfire源码中的插件

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

    clip_image008

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

    二、开发简单插件

    工程现在的目录机构如下

    clip_image010

    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 hoojo_@126.com
     * @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目录结构如下:

    clip_image012

    首先看看文件命名,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,我们看看实际开发中的目录结构:

    clip_image014

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

    clip_image016

    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这个命令即可。执行命令后,你可以看到工作空间的工程目录下多了目录和文件。见图:

    clip_image018

    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包)。

    clip_image020

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

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

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

    clip_image022

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

    三、开发带jsp、PluginServlet的插件

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

    在之前的目录下添加文件,目录结构如下:

    clip_image024

    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 hoojo_@126.com
     * @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插件目录结构如下:

    clip_image026

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

    clip_image028

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

     

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

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

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


    展开全文
  • openfire插件编译

    2017-03-17 10:55:48
    openfire默认编译时,是同时编译主程序和所有在plugins目录中的插件。但进行插件开发时,这样编译就太费时费力。 使用ant plugins可以只编译插件,能够节省部分时间。 最节省时间的编译方法为在命令行下使用ant ...
    openfire默认编译时,是同时编译主程序和所有在plugins目录中的插件。但进行插件开发时,这样编译就太费时费力。
    
    使用ant plugins可以只编译插件,能够节省部分时间。
    最节省时间的编译方法为在命令行下使用ant plugin -Dplugin=xxx进行编译,其中,xxx为插件名字( 生成到work文件夹下的jar和插件文件夹的名称最好和插件文件夹名一致否则会出现插件卸载不掉的问题!本文中就犯了这样的错误而导致插件无法卸载(原插件文件夹名为areabroadcast) ),这样就可以只编译指定的一个插件,省时省力。
    在eclispe中的设置方法如下:

    1、首先把openfire的builder.xml文件加入ant视图里。如图:



    2、找到plugin目标,选中"打开外部工具对话框



    3、输入这个编译的名称,以及要编译的插件,参数形式为-Dplugin=xxx



    4、在targets中选中plugin



    5、保存后,配置过程就完成了。要编译时,只需要选中ant build...,然后选中自己定义的名字即可


    展开全文
  • openfire插件,本插件直接在openfire里安装即可,集成消息在线和离线的存储、查询接口,图片、表情、语音文件的上传和下载对外接口,因此,不需要修改openfire源码即可满足聊天的实用功能,对外提供3个接口,一消息...
  • 由于Openfire的房间是当用户加入退出登录后,用户也自动退出了该房间,当下次再登录时,需要重新出席加入房间,没有能像QQ群那样持久保持的功能。 为了实现房间的持久保存,设计这个插件的思路就是,使用org....
  • NULL 博文链接:https://bsr1983.iteye.com/blog/2240070
  • GMPP协议及其服务器端的Openfire插件开发 GMPP背景知识 GMPP是一种基于GML的协议它继承了在 GML环境中灵活的发展性 因此基于GMPP的应用具有超强的可扩展性 绊过扩展以后的GMPP可以通 过发送扩展的信息来处理用户的...
  • openfire 插件简单示例

    2014-05-14 00:24:34
    openfire插件开发(plugin sevlet)入门 了解简单示例,有助于快速开发插件。 快速方便地使用build.xml进行ant打包编译
  • 导入openfire之后,就等待插件下载。如果是第一次创建,下载插件比较多,要等比较长的时间。 2、配置项目 IntelliJ IDEA: 1、Run -> Edit Configurations… -> Add Application 2、fill in following ...
  • openfire消息回执插件

    2019-08-02 11:37:17
    NULL 博文链接:https://xrb2008.iteye.com/blog/1972738
  • openfire插件最佳实践(二)基于IQHandler 的Smack+openfire插件 原创 2013年12月30日 12:02:09 6105 简单插件开发已经讲解了简单的openfire插件怎样制作,本篇将会讲解如何实现一个...
  • openfire 插件

    2013-03-25 17:06:57
    这篇是简单插件开发,下篇聊天记录插件。 开发环境: System:Windows WebBrowser:IE6+、Firefox3+ JavaEE Server:tomcat5.0.2.8、tomcat6 IDE:eclipse、MyEclipse 8 开发依赖库: Jdk1.6、...
  • 由于我们的openfire插件引入的包越来越多,导致插件也越来越大,而且openfire3.10.x之后取消了pack200的打包方式(压缩),导致打包出来的插件越来越大,大概10M左右,上传速度大概200KB/s,有时候上传插件到50%多,...
  • 此部分是Openfire的第三大...在openfire插件源码的plugins目录下新建文件夹messageFilter messageFilter文件夹下新建lib和src文件夹。lib包下放jar包,src文件夹下放要开发的插件源码。 将changelog.html、logo...
  • 开始想法是修改openfire源码,但修改后发现不好测试,不会发布,不会使用,各种不会,,,于是了解到最好编写 openfire 插件,利于更新插件版本,方便更新整体openfire。于是踏上openfire 插件之路。。 网上很好...
  • 这是 Openfire XMPP 服务器的插件,用于使用 IQ 注册访问者用户的电子邮件。 想要将其电子邮件注册到 XMPP 服务器的访问者应发送 IQ 查询: < email>"email address" < nick>"nickname" 成功后,将发出...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,950
精华内容 1,180
关键字:

openfire插件