精华内容
下载资源
问答
  • WEB集成管理定义与应用意义 定义: Web集成管理是指企业自身在网络上的推广、宣传、客户接触、互动等进行统一全方位的网络商业应用的解决方案。 应用意义: Web集成管理是指CRM系统中,对与客户接触的Web渠道、...

    WEB集成管理定义与应用意义

    定义

    Web集成管理是指企业自身在网络上的推广、宣传、客户接触、互动等进行统一全方位的网络商业应用的解决方案。

    应用意义:

    Web集成管理是指CRM系统中,对与客户接触的Web渠道、信息的处理和相关技术支持进行的管理活动。CRM系统可通过Web支持、销售其产品和服务并不断扩展销售和服务体系,并可与ERP等应用系统结合,改善产品的发布和生产周期。Web集成管理是CRM系统的客户合作管理子系统的重要组成部分。企业在CRM应用中开展Web集成管理的主要工作是建立统一的企业信息门户,以及在此基础上管理和建设Web营销网站,实现不同渠道信息的传递和交流oCRM的Web集成管理指应用Intemet体系结构,提供一个从选择配置到订货的个人化的电子商务解决方案的新接口,从而全面支持Intemet交易,使企业能够充分利用Intemet扩展自己的电子商务,这对于企业实施有针对性和个性化的市场战略具有重要的意义。

    发展理念

    美国著名的市场分析公司“数据监控者”指出,1999年全世界因没有集成的网络客户服务而损失了约61亿美元的网上交易。这个数据充分说明,在企业推行电子商务时,对于网络集成方案的重视应当从CRM应用之初就开始。

    WEB在shareinstall上的集成应用

    首先,我们要了解移动开发者需要用web达到怎样的效果,才能更理解web在此项实例中应用的精髓。shareinstall的核心价值在于,帮助Android/iOS开发者通过shareinstall提供的sdk,精确的获取app每一次安装的分享(或推广)来源。那么,从shareinstall的渠道统计这项功能来看,确定的API和自动打包的链接,是攻克的难点。

    Shareinstall SDK WEB集成代码代码如下:

    <!-- 建议直接引用下面的js链接,以便得到最及时的更新,我们将持续跟踪各种主流浏览器的变化,为您提供最好的服务-->
    <script type="text/javascript" src="//www.shareinstall.com/js/page/shareinstall.min.js"></script>
    <script type="text/javascript">
        //错误处理:确保app始终能正常的安装
        var timer = setTimeout(
            function() {
                var button = document.getElementById("downloadButton");
                button.style.visibility = "visible";
                button.onclick = function() {
                    var ua = navigator.userAgent;
                    if (ua.indexOf(" MicroMessenger/") > -1) {
                        //微信中显示遮罩提示在浏览器中打开或进入应用宝
                        var div = document.createElement("div");
                        div.innerHTML = "<div style="font-size:2rem;color:#fff;text-align:center;"
                            +"position:fixed;left:0;top:0;background:rgba(0,0,0,0.5);filter:alpha(opacity=50);"
                            +"width:100%;height:100%;z-index:10000;">点击右上角在浏览器中打开</div>";
                        document.body.appendChild(div);
                    } else {
                        if (ua.indexOf("Android") > -1) {
                            //直接下载apk
                            //window.location="apk地址";
                        } else if (ua.indexOf("iPhone") > -1 || ua.indexOf("iPad") > -1
                            || ua.indexOf("iPod") > -1) {
                            //直接进入appstore
                            //window.location="appstore地址";
                        }
                    }
                }
            }, 5000);
    
        //shareinstall初始化,初始化时将与shareinstall服务器交互,应尽可能早的调用
        /*web页面向app传递的json数据(json string/js Object),应用被拉起或是首次安装时,通过相应的
         android/ios api可以获取此数据*/
        var data = ShareInstall.parseUrlParams();//shareinstall.js中提供的工具函数,解析url中的所有查询参数
        new ShareInstall({
            appKey : 'F6BKAREBHF22EB',
            onready : function() {
                //shareinstall已成功回调,清除定时器
                clearTimeout(timer);
                timer = null;
    
                var m = this, button = document.getElementById("downloadButton");
                button.style.visibility = "visible";
    
                /*用户点击某个按钮时(假定按钮id为downloadButton),安装app*/
                button.onclick = function() {
                    m.wakeupOrInstall();
                }
            }
        }, data);
    </script>

    同时逆向供给,shareinstall提供完整的javascript api,方便Web开发者实现完全自主的设计。如此而来,web开发者与移动开发者竟生成互利共生的关系。ShareinstallSDK量级较轻,应用集成造成的代码冗余少,集成简单。携参安装实现个性化,渠道统计更精确,提供通用一键拉起接口。作为一款优秀好用的开放SDK,的确是移动开发者不可或缺的最佳拍档。

    展开全文
  • 下面,结合CI和CD两种不同软件生产实践,总结一下如何从零开始部署一套web集成测试环境。 1.服务器准备。根据项目和使用的中间件的规模,准备好一个或多个资源配置能够满足要求的服务器,一般选用linux下 centos的...

            测试环境的搭建是一名合格QA必须具备的技能。下面,结合CI和CD两种不同软件生产实践,总结一下如何从零开始部署一套web集成测试环境。

    1.服务器准备。根据项目和使用的中间件的规模,准备好一个或多个资源配置能够满足要求的服务器,一般选用linux下 centos的某个发行版作为服务器。

     

    2.安装数据库、完成数据库表的建立。这里以开源的mysql为例。

    Yum方式安装msyql,并启动mysql服务。(Yum的安装可以参考http://blog.csdn.net/iamhuanggua/article/details/60140867

    yuminstall -y mysql-server mysql mysql-devel

    创建数据库和建表。规范的的系统,一般都保留有现成的SQL脚本,执行脚本就可以完成数据库和表的建立。

     

    3.安装和配置JDK、tomcat、nginx...

    安装JDK。Yum 方式安装最新版JDK:yum install JDK。

    安装tomcat。官网下载tomcat,解压。

    wget http://apache.fayea.com/tomcat/tomcat-7/v7.0.75/bin/apache-tomcat-7.0.75-linux-x64.zip

    安装和配置 nginx。官网下载nginx,解压后,修改conf/nginx.conf配置请求转发规则。

     

    4.安装持续集成工具jenkins.

    Jenkins就是一个web服务,只需要从官方下载jenkins的war包,部署到web容器tomcat的webapp目录下,启动tomcat服务,就可以在浏览器端输入IP和端口号(例如:部署在本机上可以通过 localhost:8080/jenkins 进行访问)使用了。

     

    5.配置一个Jenkins job用于编译、打包产品、部署到测试环境

    5.1 配置job完成编译和打包。编译打包的Jenkinsjob的配置比较简单,可以自行百度。

    5.2 在部署web服务的机器上,找一个目录,写一个shell脚本,拷贝jenkins job打出来的包到web服务器的部署目录下,并重启服务。如果部署jenkins 和部署web服务的机器不是同一台,需要通过用户名密码或者建立linux机器之间的信任关系后,通过scp远程拷贝。

    5.3 在5.1的job中,增加“构建后操作”,构建后执行(或远程执行)5.2中编写的sh脚本。

     

    6.配置一个或多个Jenkins job 用来完成一系列测试(包括但不限于UI自动化、接口自动化、安全测试等)

    测试job的构建方式选择步骤五中配置的job完成后触发。到此为此,持续集成的工作就完成了。

     

    7.从CI到CD——配置一个Jenkins job 完成生产环境部署

    如果所在组织的持续集成能力较高,在实施持续部署(Continous Deployment),就还需要配置一个jenkins job在所有测试job都通过后触发部署生产包到生产环境。部分用户群较大的产品还需要配置灰度发布。

    展开全文
  • web集成帆软报表7.0,报表正常显示,图表不显示,不报错
  • Shiro学习笔记(5)——web集成

    千次阅读 2015-06-02 10:45:03
    Web集成 shiro配置文件shiroini 界面 webxml最关键 Servlet 测试 基于 Basic 的拦截器身份验证Web集成大多数情况,web项目都会集成spring。shiro在普通web项目和spring项目中的配置是不一样的。关于spring-shiro集成...

    Web集成

    大多数情况,web项目都会集成spring。shiro在普通web项目和spring项目中的配置是不一样的。关于spring-shiro集成,可以参考Shiro学习笔记(3)——授权(Authorization) 中的JSP标签授权部分示例代码

    本次介绍普通的web项目,不使用任何框架。

    shiro配置文件(shiro.ini)

    创建web项目,然后在src下创建shiro.ini

    [main]
    #默认的登录界面是/login.jsp
    authc.loginUrl=/login.jsp
    roles.unauthorizedUrl=/unauthorized
    perms.unauthorizedUrl=/unauthorized
    authcBasic.applicationName=please login
    [users]
    zhang=123,admin
    wang=123
    [roles]
    admin=user:*,menu:*
    [urls]
    /login=anon
    /success=authc
    /unauthorized=anon
    /static/**=anon
    /authenticated=authc
    /role=authc,roles[admin]
    /permission=authc,perms["user:create"]

    关于配置文件的具体说明,可以参考Shiro学习笔记(4)——ini 配置

    这里需要关注的有几个:

    • authc.loginUrl=/login.jsp
    • /login=anon
    • /success=authc

    当访问/success这个路径的时候,如果没有登录,将会自动跳转到登录界面/login.jsp,访问/login这个路径的时候,可以不用登录

    界面

    准备登录界面和登录成功的界面

    登录界面

    <%@ page language="java" contentType="text/html; charset=ISO-8859-1"
        pageEncoding="ISO-8859-1"%>
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    <html>
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
    <title>请登录</title>
    </head>
    <body>
        <h1>login</h1>
        <form action="login">
            <label>username:</label>
            <input type="text" name="username"/>
            <label>password:</label>
            <input type="text" name="password"/>
            <input type="submit" value="submit"/>
        </form>
    </body>
    </html>

    登录成功界面

    <%@ page language="java" contentType="text/html; charset=ISO-8859-1"
        pageEncoding="ISO-8859-1"%>
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    <html>
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
    <title>登录成功</title>
    </head>
    <body>
    <h1>SUCCESSFUL</h1>
    </body>
    </html>

    web.xml(最关键)

    这是最关键的步骤

    <?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
      <display-name>shiro-web</display-name>
      <!-- 该配置的作用是让shiro在项目启动的时候随之启动 -->
      <listener>
        <listener-class>org.apache.shiro.web.env.EnvironmentLoaderListener</listener-class>
      </listener>
      <!-- 配置shiro配置文件的位置,默认位置是/WEB-INF/shiro.ini -->
      <context-param>
        <param-name>shiroConfigLocations</param-name>
        <param-value>classpath:shiro.ini</param-value>
      </context-param>
      <!-- shiro过滤器 -->
      <filter>
        <filter-name>ShiroFilter</filter-name>
        <filter-class>org.apache.shiro.web.servlet.ShiroFilter</filter-class>
      </filter>
      <filter-mapping>
        <filter-name>ShiroFilter</filter-name>
        <url-pattern>/*</url-pattern>
        <dispatcher>REQUEST</dispatcher>
        <dispatcher>FORWARD</dispatcher>
        <dispatcher>INCLUDE</dispatcher>
        <dispatcher>ERROR</dispatcher>
      </filter-mapping>
    </web-app>

    Servlet

    LoginServlet:处理登录请求的servlet,如果登录成功,重定向到/success

    package com.shiro.servlet;
    
    import java.io.IOException;
    
    import javax.servlet.ServletException;
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import org.apache.shiro.SecurityUtils;
    import org.apache.shiro.authc.AuthenticationException;
    import org.apache.shiro.authc.IncorrectCredentialsException;
    import org.apache.shiro.authc.UnknownAccountException;
    import org.apache.shiro.authc.UsernamePasswordToken;
    import org.apache.shiro.subject.Subject;
    
    /**
     * Servlet implementation class LoginServlet
     */
    @WebServlet(name="/LoginServlet",urlPatterns="/login")
    public class LoginServlet extends HttpServlet {
        private static final long serialVersionUID = 1L;
    
        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            String username = request.getParameter("username");
            String password = request.getParameter("password");
    
            Subject currentUser = SecurityUtils.getSubject();
    
            UsernamePasswordToken token = new UsernamePasswordToken(username,password);
            try {
                currentUser.login(token);
            } catch (UnknownAccountException e) {
                System.out.println("沒有這個用戶");
            } catch (IncorrectCredentialsException e) {
                System.out.println("密碼錯誤");
            } catch (AuthenticationException e) {
            //其他错误,比如锁定,如果想单独处理请单独 catch 处理
                System.out.println("其他错误:" + e.getMessage());
            }
            response.sendRedirect(request.getContextPath()+"/success");
        }
    
    
        protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            doGet(request, response);
        }
    
    }
    

    SuccessServlet:登录成功界面对应Servlet,只起到转发的作用

    package com.shiro.servlet;
    
    import java.io.IOException;
    import javax.servlet.ServletException;
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    /**
     * Servlet implementation class SuccessServlet
     */
    @WebServlet(name="/SuccessServlet",urlPatterns="/success")
    public class SuccessServlet extends HttpServlet {
        private static final long serialVersionUID = 1L;
    
    
        /**
         * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
         */
        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            request.getRequestDispatcher("/WEB-INF/views/success.jsp").forward(request, response);
        }
    
        /**
         * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
         */
        protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            doGet(request, response);
        }
    
    }
    

    测试

    • 访问/success,shiro发现我们还未登录,自动跳转到/login.jsp界面

    这里写图片描述

    • 输入用户名密码(shiro.ini中有配置),登录成功,跳转到成功界面

    这里写图片描述

    做到这里,基本的web集成就已经完成,但是在实际开发中,我们通常需要配置Realm等其他组件,从数据库中读取用户信息,用户的角色,权限等,可以参考Shiro学习笔记(2)——身份验证之Realm

    基于 Basic 的拦截器身份验证

    什么是基于Basic的拦截器呢?在上面的代码中,我们访问/success时,shiro发现我们没登录,就自动跳转到/login.jsp界面
    所谓的基于Basic的拦截器,就是当我们没登录时,不跳转到/login.jsp界面,而是跳出下面这个框让我们登录
    这里写图片描述

    整个过程和效果和上面是一样的,不过平时一般也不会用到这个。而且我发现这个在谷歌浏览器中不起作用,火狐和IE都可以。不知道是不是本人人品问题。

    怎么做??在shiro.ini中修改一行配置即可

    [urls]
    /success=authcBasic
    展开全文
  • Beetl学习总结(4)——Web集成

    万次阅读 2016-11-07 15:25:27
    Web集成模块向模板提供web标准的变量,做如下说明 request 中的所有attribute.在模板中可以直接通过attribute name 来引用,如在controller层 request.setAttribute("user",user),则在模板中可以直接用${user....

    4.1. Web提供的全局变量

    Web集成模块向模板提供web标准的变量,做如下说明

    • request 中的所有attribute.在模板中可以直接通过attribute name 来引用,如在controller层 request.setAttribute("user",user),则在模板中可以直接用${user.name} .

    • session 提供了session会话,模板通过session["name"],或者session.name 引用session里的变量

    • request 标准的HTTPSerlvetRequest,可以在模板里引用request属性(getter),如${request.requestURL}。

    • parameter 用户读取用户提交的参数。如${parameter.userId} (仅仅2.2.7以上版本支持)

    • ctxPath Web应用ContextPath

    • servlet 是WebVariable的实例,包含了HTTPSession,HTTPSerlvetRequest,HTTPSerlvetResponse.三个属性,模板中可以通过request.response,session 来引用,如 ${serlvet.request.requestURL};

    • 所有的GroupTemplate的共享变量

    • pageCtx是一个内置方法 ,仅仅在web开发中,用于设置一个变量,然后可以在页面渲染过程中,调用此api获取,如pageCtx("title","用户添加页面"),在其后任何地方,可以pageCtx("title") 获取该变量。(仅仅2.2.7以上版本支持)

    你可以在模板任何地方访问这些变量

    如果你需要扩展更多属性,你也可以配置beetl.properties配置文件的WEBAPP_EXT属性,实现WebRenderExt接口,在渲染模板之前增加自己的扩展,如:

    1
    2
    RESOURCE.root=/WEB-INF/views
    WEBAPP_EXT = com.park.oss.util.GlobalExt
    
     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    public class GlobalExt implements WebRenderExt{
    
            static long version = System.currentTimeMillis();
            @Override
            public void modify(Template template, GroupTemplate arg1, HttpServletRequest arg2, HttpServletResponse arg3) {
                    //js,css 的版本编号
                    template.binding("sysVersion",version);
            }
    
    }
    

    这样,每次在模板里都可以访问变量sysVersion了,不需要再controller里设置,或者通过servlet filter来设置

    4.2. 集成技术开发指南

    Beetl默认提供了WebRender用于帮助web集成开发,所有内置的集成均基于此方法。如果你认为Beetl内置的各个web框架集成功能不够,你可以继承此类,或者参考此类源码重新写,其代码如下

      1
      2
      3
      4
      5
      6
      7
      8
      9
     10
     11
     12
     13
     14
     15
     16
     17
     18
     19
     20
     21
     22
     23
     24
     25
     26
     27
     28
     29
     30
     31
     32
     33
     34
     35
     36
     37
     38
     39
     40
     41
     42
     43
     44
     45
     46
     47
     48
     49
     50
     51
     52
     53
     54
     55
     56
     57
     58
     59
     60
     61
     62
     63
     64
     65
     66
     67
     68
     69
     70
     71
     72
     73
     74
     75
     76
     77
     78
     79
     80
     81
     82
     83
     84
     85
     86
     87
     88
     89
     90
     91
     92
     93
     94
     95
     96
     97
     98
     99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    package org.beetl.ext.web;
    
    import java.io.IOException;
    import java.io.OutputStream;
    import java.io.Writer;
    import java.util.Enumeration;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import org.beetl.core.GroupTemplate;
    import org.beetl.core.Template;
    import org.beetl.core.exception.BeetlException;
    
    /**
     *  通常web渲染的类,将request变量赋值给模板,同时赋值的还有session,request,ctxPath
     *  其他框架可以继承此类做更多的定制
     * @author joelli
     *
     */
    public class WebRender
    {
            GroupTemplate gt = null;
    
            public WebRender(GroupTemplate gt)
            {
                    this.gt = gt;
            }
    
            /**
             * @param key 模板资源id
             * @param request
             * @param response
             * @param args 其他参数,将会传给modifyTemplate方法
             */
            public void render(String key, HttpServletRequest request, HttpServletResponse response, Object... args)
            {
                    Writer writer = null;
                    OutputStream os = null;
                    try
    
                    {
                            //                      response.setContentType(contentType);
                            Template template = gt.getTemplate(key);
                            Enumeration<String> attrs = request.getAttributeNames();
    
                            while (attrs.hasMoreElements())
                            {
                                    String attrName = attrs.nextElement();
                                    template.binding(attrName, request.getAttribute(attrName));
    
                            }
                            WebVariable webVariable = new WebVariable();
                            webVariable.setRequest(request);
                            webVariable.setResponse(response);
                            webVariable.setSession(request.getSession());
    
                            template.binding("session", new SessionWrapper(webVariable.getSession()));
    
                            template.binding("servlet", webVariable);
                            template.binding("request", request);
                            template.binding("ctxPath", request.getContextPath());
    
                            modifyTemplate(template, key, request, response, args);
    
                            String strWebAppExt = gt.getConf().getWebAppExt();
                            if(strWebAppExt!=null){
                                    WebRenderExt renderExt = this.getWebRenderExt(strWebAppExt);
                                    renderExt.modify(template, gt, request, response);
                            }
                            if (gt.getConf().isDirectByteOutput())
                            {
                                    os = response.getOutputStream();
                                    template.renderTo(os);
                            }
                            else
                            {
                                    writer = response.getWriter();
                                    template.renderTo(writer);
                            }
    
                    }
                    catch (IOException e)
                    {
                            handleClientError(e);
                    }
                    catch (BeetlException e)
                    {
                            handleBeetlException(e);
                    }
    
                    finally
                    {
                            try
                            {
                                    if (writer != null)
                                            writer.flush();
                                    if (os != null)
                                    {
                                            os.flush();
                                    }
                            }
                            catch (IOException e)
                            {
                                    handleClientError(e);
                            }
                    }
            }
    
            /**
             * 可以添加更多的绑定
             * @param template 模板
             * @param key 模板的资源id
             * @param request
             * @param response
             * @param args  调用render的时候传的参数
             */
            protected void modifyTemplate(Template template, String key, HttpServletRequest request,
                            HttpServletResponse response, Object... args)
            {
    
            }
    
            /**处理客户端抛出的IO异常
             * @param ex
             */
            protected void handleClientError(IOException ex)
            {
                    //do nothing
            }
    
            /**处理客户端抛出的IO异常
             * @param ex
             */
            protected void handleBeetlException(BeetlException ex)
            {
                    throw ex;
            }
    }
    

    4.3. Serlvet集成

    只需要在Servlet代码里引用ServletGroupTemplate就能集成Beetl,他提供了一个render(String child, HttpServletRequest request, HttpServletResponse response)方法。例子如下:

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    protected void doGet(HttpServletRequest request,
                            HttpServletResponse response) throws ServletException, IOException {
    
                    response.setContentType("text/html;charset=UTF-8");
                    //模板直接访问users
                    request.setAttribute("users",service.getUsers());
                    ServletGroupTemplate.instance().render("/index.html", request, response);
    
    
            }
    

    ServletGroupTemplate同其他web集成一样,将读取配置文件来配置,如果需要通过代码配置,可以在Serlvet listener里 ServletGroupTemplate.instance().getGroupTemplate()方法获取GroupTemplate

    4.4. SpringMVC集成

    需要做如下配置即可

    1
    2
    3
    4
    5
    6
    <bean id="beetlConfig" class="org.beetl.ext.spring.BeetlGroupUtilConfiguration" init-method="init"/>
    
    
    <bean id="viewResolver" class="org.beetl.ext.spring.BeetlSpringViewResolver">
            <property name="contentType" value="text/html;charset=UTF-8"/>
    </bean>
    

    同其他集成方式一样,模板的配置将放在beetl.properties中。

    如果想获取GroupTemplate,可以调用如下代码

    1
    2
    3
    BeetlGroupUtilConfiguration config = (BeetlGroupUtilConfiguration) this.getApplicationContext().getBean(
                                    "beetlConfig");
    GroupTemplate group = config.getGroupTemplate();
    

    Controller代码如下:

    1
    2
    3
    4
    5
    6
    7
    @RequestMapping(value = "/", method = RequestMethod.GET)
    public ModelAndView index(HttpServletRequest req) {
            ModelAndView view = new ModelAndView("/index");
            //total 是模板的全局变量,可以直接访问
            view.addObject("total",service.getCount());
      return view;
    }
    

    4.5. SpringMVC集成高级

    spring集成还允许注册被spring容器管理的Function,Tag等,也还允许配置多个视图解析器等功能

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    <bean name="beetlConfig" class="org.beetl.ext.spring.BeetlGroupUtilConfiguration" init-method="init">
            <property name="configFileResource" value="/WEB-INF/beetl.properties"/>
            <property name="functions">
                 <map>
                   <entry key="testFunction" value-ref="testFunction"/>
                </map>
            </property>
    
            <property name="functionPackages">
                 <map>
                   <entry key="fp" value-ref="testFunctionPackage"/>
                </map>
            </property>
    
            <property name="tagFactorys">
                 <map>
                   <entry key="html.output" value-ref="testTagFactory"/>
                   <entry key="html.output2" value-ref="testTagFactory2"/>
                </map>
            </property>
    
    </bean>
    
    <bean name="testTagFactory" class="org.beetl.ext.spring.SpringBeanTagFactory">
         <property name="name" value="testTag"/>
    </bean>
    <bean name="testTagFactory2" class="org.beetl.ext.spring.SpringBeanTagFactory">
         <property name="name" value="testTag2"/>
    </bean>
    
    
    <bean name="beetlViewResolver" class="org.beetl.ext.spring.BeetlSpringViewResolver">
            <property name="config" ref="beetlConfig"/>
            <property name="contentType" value="text/html;charset=UTF-8"/>
    </bean>
    

    如上图所示,BeetlGroupUtilConfiguration有很多属性,列举如下

    • configFileResource 属性指定了配置文件所在路径,如果不指定,则默认在classpath下

    • functions 指定了被spring容器管理的function,key为注册的方法名,value-ref 指定的bean的名称

    • functionPackages,指定了被spring容器管理的functionPackage,key为注册的方法包名,value-ref 指定的bean的名称

    • tagFactorys ,注册tag类,key是tag类的名称,value-ref指向一个org.beetl.ext.spring.SpringBeanTagFactory实例,该子类是一个Spring管理的Bean。属性name对应的bean就是tag类。需要注意,由于Tag是有状态的,因此,必须申明Scope为 "prototype"。如代码:

    1
    2
    3
    4
    @Service
    @Scope("prototype")
    public class TestTag extends Tag {
    }
    
    • typeFormats: 同functions,参数是 Map<Class<?>, Format>,其中key为类型Class

    • formats:同functions,参数是 Map<String, Format>,其中key为格式化函数名

    • virtualClassAttributes 同functions,参数Map<Class<?>, VirtualClassAttribute>,其中key为类型Class

    • virtualAttributeEvals ,类型为List<VirtualAttributeEval>

    • resourceLoader,资源加载器 ,值是 实现ResourceLoader的一个Bean

    • errorHandler ,错误处理,值是实现ErrorHandler的一个Bean

    • sharedVars,同functions,类型是Map<String, Object>,可以在此设置共享变量

    • configProperties,类型是Properties,可以覆盖配置文件的某些属性

    如下配置,指定了三个视图解析器,一个用于beetl页面渲染,一个用于cms,采用了beetl技术,另外一个一些遗留的页面采用jsp

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    <bean name="beetlConfig" class="org.beetl.ext.spring.BeetlGroupUtilConfiguration" init-method="init">
            <property name="configFileResource" value="/WEB-INF/beetl.properties"/>
    </bean>
    
    
    <bean name="cmsbeetlConfig" class="org.beetl.ext.spring.BeetlGroupUtilConfiguration" init-method="init">
            <property name="configFileResource" value="/WEB-INF/cms-beetl.properties"/>
    </bean>
    
    
    <!-- Beetl视图解析器1 -->
    <bean name="beetlViewResolver" class="org.beetl.ext.spring.BeetlSpringViewResolver">
            <!-- 多视图解析器,需要设置viewNames和order -->
            <property name="viewNames">
                    <list>
                            <value>/template/**</value>
                    </list>
            </property>
            <property name="suffix" value=".btl"/>
            <property name="contentType" value="text/html;charset=UTF-8"/>
            <property name="order" value="0"/>
            <!-- 多GroupTemplate,需要指定使用的bean -->
            <property name="config" ref="beetlConfig"/>
    
    </bean>
    
    <!-- Beetl视图解析器2 -->
    <bean name="cmsBeetlViewResolver" class="org.beetl.ext.spring.BeetlSpringViewResolver">
            <!-- 多视图解析器,需要设置viewNames和order -->
            <property name="viewNames">
                    <list>
                            <value>/cmstemplate/**</value>
                    </list>
            </property>
            <property name="contentType" value="text/html;charset=UTF-8"/>
            <property name="order" value="1"/>
            <!-- 多GroupTemplate,需要指定使用的bean -->
            <property name="config" ref="cmsbeetlConfig"/>
    
    </bean>
    
    <!-- JSP视图解析器 -->
    <bean name="JSPViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            <!-- 注意JSP的这个视图解析器order必须在最后 -->
            <property name="order" value="256"/>
            <!-- beetl配置不支持前缀,这不同于jsp 和 freemaker -->
            <property name="prefix" value="/WEB-INF/"/>
            <property name="suffix" value=".jsp"/>
            <property name="contentType" value="text/html;charset=UTF-8"/>
    </bean>
    

    Beetl视图解析器属性同spring自带的视图解析器一样,支持contentType,order,prefix,suffix等属性。

    注意视图解析器里属性viewNames,这个用于判断controller返回的path到底应该交给哪个视图解析器来做。

    • 以/template开头的是beetlViewResolver来渲染。

    • 以/cmstemplate是交给cmsBeetlViewResolver渲染。

    • 如果都没有匹配上,则是jsp渲染

    如果你想更改此规则,你只能增加canHandle方法指定你的逻辑了。详情参考org.springframework.web.servlet.view.UrlBasedViewResolver.canHandle

    对于仅仅需要redirect和forward的那些请求,需要加上相应的前缀

    • 以"redirect:"为前缀时:表示重定向,不产生BeetlView渲染模版,而直接通过Servlet的机制返回重定向响应.redirect:前缀后面的内容为重定向地址,可以采用相对地址(相对当前url),绝对地址(完整的url),如果采用/开头的地址,会自动的在前面接上当前Web应用的contextPath,即contextPath为test的Web应用中使用redirect:/admin/login.html 实际重定向地址为 /test/admin/login.html

    • 以"forward:"为前缀时:表示转发,不产生BeetlView渲染模版。而是直接通过Servlet的机制转发请求(关于转发和重定向的区别,请自行查看Servlet API) forward:前缀后面的内容为转发地址,一般都是以/开头相对于当前Web应用的根目录

    其他集成需要注意的事项:

    • spring集成,请不要使用spring的 前缀配置,改用beetl的RESOURCE.ROOT 配置,否则include,layout会找不到模板

    4.6. Spring Boot集成

    Spring Boot 通过java config来配置 beetl需要的BeetlGroupUtilConfiguration,和 BeetlSpringViewResolver,参考代码如下

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    @Configuration
    public class BeetlConf {
    
    
            @Value("${beetl.templatesPath}") String templatesPath;//模板跟目录
    
            @Bean(initMethod = "init", name = "beetlConfig")
        public BeetlGroupUtilConfiguration getBeetlGroupUtilConfiguration() {
            BeetlGroupUtilConfiguration beetlGroupUtilConfiguration = new BeetlGroupUtilConfiguration();
            try {
                ClasspathResourceLoader cploder = new ClasspathResourceLoader(BeetlConf.class.getClassLoader(),templatesPath);
                beetlGroupUtilConfiguration.setResourceLoader(cploder);
                return beetlGroupUtilConfiguration;
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
    
        }
    
        @Bean(name = "beetlViewResolver")
        public BeetlSpringViewResolver getBeetlSpringViewResolver(@Qualifier("beetlConfig") BeetlGroupUtilConfiguration beetlGroupUtilConfiguration) {
            BeetlSpringViewResolver beetlSpringViewResolver = new BeetlSpringViewResolver();
            beetlSpringViewResolver.setContentType("text/html;charset=UTF-8");
            beetlSpringViewResolver.setOrder(0);
            beetlSpringViewResolver.setConfig(beetlGroupUtilConfiguration);
            return beetlSpringViewResolver;
        }
    
     }
    

    spring boot集成需要注意的是要添加spring-devtools.properties文件,并配置如下选项

    1
    2
    restart.include.beetl=/beetl-xxx.jar
    restart.include.beetlsql=/beetlsql-xxx..jar
    

    spring-devtools.properties 为spring boot的配置文件,位于META-INF目录下

    4.7. Jodd集成

    需要配置web.xml,将所有请求交给jodd处理,参考:http://jodd.org/doc/madvoc/setup.html

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    <filter>
            <filter-name>madvoc</filter-name>
            <filter-class>jodd.madvoc.MadvocServletFilter</filter-class>
            <init-param>
                            <param-name>madvoc.webapp</param-name>
                            <param-value>test.MyWebApplication</param-value>
              </init-param>
        <init-param>
                    <param-name>madvoc.configurator</param-name>
                    <param-value>test.MyAutomagicMadvocConfigurator</param-value>
            </init-param>
    
    </filter>
    <filter-mapping>
            <filter-name>madvoc</filter-name>
            <url-pattern>/*</url-pattern>
    </filter-mapping>
    

    MyWebApplication 和 MyAutomagicMadvocConfigurator 需要自己参照如下例子写一个,前者用来设置beetl作为视图渲染,后者配置Jodd不要扫描beetl struts集成里引用的struts类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    public class MyAutomagicMadvocConfigurator extends AutomagicMadvocConfigurator {
            public MyAutomagicMadvocConfigurator(){
                    super();
                    //不扫描beetl 里jar文件里的action和result,否则,会扫描StrutsResultSupport不相干的class
                    this.rulesJars.exclude("**/*beetl*.jar");
    
    
            }
    }
    
    1
    2
    3
    4
    5
    6
    7
    8
    public class MyWebApplication  extends WebApplication{
         @Override
         protected void init(MadvocConfig madvocConfig, ServletContext servletContext) {
                     //设置默认
             madvocConfig.setDefaultActionResult(BeetlActionResult.class);
    
         }
     }
    

    最后,可以写Action了,浏览器输入/index.html,jodd将执行world方法,并渲染ok.html模板。如果你想配置GroupTemplate,正如其他集成框架一样,只需要写一个beetl.properties 即可。

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    @MadvocAction
    public class IndexAction {
    
         @Out
         String value;
         @Action("/index.html")
         public String world() {
    
             value = "Hello World!";
             return "/ok.html";
         }
    }
    

    4.8. JFinal集成

    Beetl提供 JFinal 集成,使用BeetlRenderFactory ,通过如下注册即可使用beetl模板引擎

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    import org.beetl.ext.jfinal.BeetlRenderFactory
    public class DemoConfig extends JFinalConfig
    {
            public void configConstant(Constants me)
            {
    
                    me.setMainRenderFactory(new BeetlRenderFactory());
                    // 获取GroupTemplate ,可以设置共享变量等操作
                    GroupTemplate groupTemplate = BeetlRenderFactory.groupTemplate ;
    
    }
    

    业务逻辑代码:

    1
    2
    3
    4
    5
    6
    7
    8
    9
            public void modify(){
                    int artId = getParaToInt(0, -1);
                    setAttr("title", "修改文章");
                    List<Cate> cateLists = Cate.getAllCate();
                    //模板里访问cateLists,atr,
                    setAttr("cateLists", cateLists);
                    setAttr("art", Article.dao.findById(artId));
                    render("/modify.html");
            }
    

    BeetlRenderFactory 默认使用FileResourceLoader ,其根目录位于WebRoot目录下,如果你需要修改到别的目录,可以设置配置文件,如

    1
    RESOURCE.root= /WEB-INF/template/
    

    https://git.oschina.net/xiandafu/beetl-jfinal-sample 有完整例子,采用jfinal+beetl写的一个博客系统

    4.9. Nutz集成

    Nutz集成提供了 BeetlViewMaker ,实现了 ViewMaker方法,如下代码

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
            @At("/ctx")
            @Ok("beetl:ctx.btl")
            public Context withContext() {
                    Context ctx = Lang.context();
                    Pager pager = dao.createPager(1, 20);
                    pager.setRecordCount(dao.count(UserProfile.class));
                    List<UserProfile> list = dao.query(UserProfile.class, null, pager);
                    ctx.set("pager", pager);
                    ctx.set("list", list);
                    return ctx;
            }
    
     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    <html>
    <head>
    <title>Beetl&Nutz</title>
    </head>
    <body>
    <p>总共 ${list.~size}<p/>
    <%
    for(user in list){
    %>
    <p>hello,${user.nickname};<p/>
    <%}%>
    
    <p>当前页${pager.pageNumber},总共${pager.pageCount}页<p/>
    </body>
    </html>
    

    需要注意的是,如果使用了nutz的obj(http://www.nutzam.com/core/mvc/view.html),则需要在模板顶部申明obj是动态对象,如

    1
    2
    3
    4
    5
    6
    <%
    directive dynamic obj
    %>
    
    ${obj.user.title}
    ${obj.user.name}
    

    4.10. Struts2集成

    需要在struts2配置文件里添加result-types做如下配置

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    <package name="default" namespace="/" extends="struts-default">
    .......
    <result-types>
            <result-type name="beetl"
                                    class="org.beetl.ext.struts2.Struts2BeetlActionResult" default="true" >
                                    <param name="contentType">text/html; charset=UTF-8</param>
            </result-type>
    </result-types>
    
    <action name="HelloWorld" class="com.beetl.struts.HelloWorld">
        <result>/hello.html</result>
    </action>
    <action name="Ajax" class="com.beetl.struts.AjaxHtml">
            <result>/table.html#table</result>
    </action>
    ........
    </package>
    

    该类会根据struts配置文件获取模板,如上例的hello.html,并将formbean的属性,以及request属性作为全局变量传递给模板

    郑重申明

    鉴于struts2有安全漏洞,而官方补丁打法很消极,所以请谨慎使用Struts2,Beetl的安全性已经通过在线体验和多个使用Beetl的网站得以体现 一旦你的struts2网站被攻破,请先确定是否是struts2 的问题

    4.11. 直接Web中运行Beetl模板

    对于web应用来说,必须通过controller才能渲染模板,beetl也可以写完模板后,在未完成controller情况下,直接渲染模板 此方法既可以作为通常的全栈式开发人员使用,也可以用于前端人员单独开发模板用。

    步骤如下:

    • 配置监听器,监听器指定对*.btl的请求进行监听(假定模板名字都是以btl.结尾)。

    • 实现监听器,该监听器继承父类 org.beetl.ext.web.SimpleCrossFilter,实现protected abstract GroupTemplate getGroupTemplate()方法。依据不同的集成方式,比如你的环境是Servlet,则只需要调用ServletGroupTemplate.instance().getGroupTemplate(),如果是Jfinal,需要调用BeetlRenderFactory.groupTemplate等

    • SimpleCrossFilter 提供一些有用的方法,可以帮助你定制一些特性,可以参考源码了解

    • 置完成后,对于要测试的模板,可以新建一个对应的伪模型文件,比如要测试模板WebRoot/user/userList.html,可以新建立WebRoot/values/user/userList.html.var 。 values是监听器默认的伪模型的根目录

    • 编辑伪模型文件,对应于userList.html需要的全局变量,userList.html.var可以申明这些些变量

    1
    2
    3
    var proudct = {id:1,name:'测试产品',pic:'xxxx.jpg'};
    var userList = [{id:2,name:'用户一'}];
    var session= {admin:{id:1,name:'admin'}};
    
    • 通过浏览器直接访问http://ip:port/user/userList.html,监听器会预先执行userList.html.var,并将返回值作为模板的全局变量,传给userList.html

    • 可以将一些公共的变量放到WebRoot/values/common.var里(比如上面代码的session). 监听器会先执行common.var,然后再执行userList.html.var

    直接访问模板前提是使用了伪模型,这与实际的项目采用的模型并不一致,因此当模板采用伪模型验证后,需要重启web应用,才能使用真正的模型去测试,否则,模板引擎会报错,这是因为beetl默认的FastRuntimeEngine会根据模型优化模板,对同一个模板不同的模型会报错,除非采用DefaultTemplateEngine 或者页面申明类型变量是动态的。

    4.12. 整合ajax的局部渲染技术

    越来越多web网站依赖于ajax,如table的翻页,流行方式是浏览器发出ajax请求,后台处理后返回一个json,浏览器端将json数据拆开,拼成一条一条的行数据,然后生成dom节点,追加到表格里。 作为另外一种可选技术,beetl支持局部渲染技术,允许后台处理返回的是一个完成的html片段,这样,前端浏览器可以直接将这个html片段追加到表格里。在我做的性能测试里,俩种方式性能差别不大(http://beetlajax.oschina.mopaas.com/)

    比如模板index.html有很多动态内容,有动态生成的菜单,有右侧的top10,也有核心区域的表格,大概内容如下

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    <#menu/>
    <#top10> ....</#top10>
    <div id="table-container" >
    <%
    //ajax片段开始
    #ajax userTable: {
    %>
    
    <table>
            <tr><td width=100>id</td><td width=100>姓名</td></tr>
            <%for(user in users){%>
            <tr><td>${user.id}</td><td>${user.name}</td></tr>
            <%}%>
    </table>
    
    当前页面<span id="current">${page!1}</span><span style="width:20px"></span>
    <a href="#"><span  class="page">next</span></a> <a href="#" ><span  class="page">pre</span></a>
    <%
    //ajax片段结尾
    }
    %>
    

    #ajax 用于告诉告诉模板引擎,此处是个局部渲染标记,标记为"userTable",对于正常渲染视图"index.html"页面,#ajax标记没什么用处,table仍能得到正常渲染。如果渲染的视图是index.html#userTable,则模板只会渲染#ajax标记得模板片段,其他部分将忽略。关于完整例子,可以参考http://beetlajax.oschina.mopaas.com/

    后台代码如下:

    1
    render("/index.html#userTable");
    

    ajax 片段渲染也支持默认情况下不渲染,仅仅做为一个片段使用,如一个页面有许多后台交互操作,并返回相应的html片段,可以将这些html片段也放到同一个模板里,使用ajax norender,表示渲染整个模板的时候默认并不需要渲染此ajax片段

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    <%
    <html>
    
    </html>
    #ajax norender success: {
    %>
    <div id="success"> 操作成功
    </div>
    
    <%
    }
    %>
    
    #ajax norender failure: {
    %>
    <div id="failure"> 操作失败
    </div>
    
    <%
    }
    %>
    

    这样,此页面默认情况下并没有输出success,和 failure片段

    注意,Ajax片段本质上是从模版的ajax标记处开始渲染,因此,ajax需要的变量在模版里也必须是全局变量,如果你只是个局部变量,beetl会报出找不到变量,即使你binding了这个变量,beetl也认为这个是局部变量,如:

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    " >
    <%
    var tableData = paras.table;
    #ajax userTable: {
    for(user in tableData);
    %>
    
    <%
    //ajax片段结尾
    }
    %>
    

    变量tableData是从paras里获取的,是个临时变量,因此就算你在后台binding了一个tableData,beetl 也不能识别。在渲染ajax片段的时候会报变量tableData找不到。改正的办法只能是让tableData全局变量。

    返回Json好还是返回html片段好?这个难以定论.

    • 从后台性能看,将模型序列化成json性能会比渲染模板性能更好,但是,json还需要前端重新解析生成最终html dom节点,这可能会延迟最终数据的现实效果。而返回的html片段就是已经生成好的dom

    • 从网络传入来看,json无疑更好的,html片段会有额外的html标记,css属性,以及有可能的js调用。传入流量有可能增加50%到100%。但是,对于web应用类,这些额外数据,并不算多。

    • 从开发效率来讲,返回html片段的开发效率更高一些,因为渲染在后台操作,可以随心所欲的用模板语言来渲染,来取得后台数据,完成复杂渲染,而json就比较困难,可以说所有的json lib都没有完美的解决办法。

    • 从用户体验上来讲,Beetl 采用ajax标记,混合了传统的模板渲染和ajax加载。用户进入页面即能看到数据,而经典的ajax json方式还需要异步加载,显示延迟。另外如果页面同时有多个ajax加载,则会对服务器造成很大的压力。

    • 关心服务器cpu消耗? 模板方式消耗更多的cpu,json方式则少点。但是俩者差距并不大。而且更多的web网站面临的情况是有富余的服务器CPU能力

    • 关心客户端CPU消耗? 过多的js无疑是客户端运行慢的主要原因。如果采用经典的json方式,返回的json数据必然还需要经过js的计算和渲染。会影响客户机器cpu。

    4.13. 在页面输出错误提示信息

    2.2.3版本以后,新增加org.beetl.ext.web.WebErrorHandler,可以在web开发的时候在页面输出提示信息,在产品模式下载后台输出提示信息(通过配置属性ESOURCE.autoCheck= true来认为是开发模式),仅仅需要配置如下:

    1
    ERROR_HANDLER = org.beetl.ext.web.WebErrorHandler
    
    展开全文
  • 第六节 与WEB集成原理分析

    千次阅读 2018-01-29 14:32:47
    前言 本小节仅仅是分析shiro的WEB环境加载的过程。...一、与WEB集成的配置 还记得吗,以前我们在没有与WEB环境进行集成的时候,为了生成SecurityManager对象,是通过手动读取配置文件生成工厂对象,再通...
  • Java Web集成第三方登录

    千次阅读 2016-06-28 16:36:06
    Java Web集成第三方登录:http://www.open-open.com/lib/view/open1441164039628.html 开放平台-web实现QQ第三方登录:http://www.cnblogs.com/Leo_wl/p/4418790.html
  • WampServer 32/64位 v3.1.7 Windows下web集成开发环境wampserver集成开发工具 wampserver集成开发工具 wampserver是Windows上的一个Web集成开发工具(平台),它允许您使用Apache2、PHP、MySQL和Mariadb创建动态Web...
  • web集成mpush开发

    千次阅读 2018-11-27 11:12:02
    服务部署方式参照:https://github.com/mywiki/mpush-doc/blob/master/SUMMARY.md完成 mpush官方详细开发文档:http://mpush.mydoc.io/?t=134820 redis默认只能本机访问,需要修改配置文件,请参考...
  • FineReport与Web集成

    万次阅读 2015-02-08 15:34:51
    报表工程目录结构  在说明配置FineReport服务器之前,我们先了解一下FineReport应用服务的目录结构: ...对上图的目录层次结构我们做一些说明: ...WebReport:可以看到所有的相关文件都...WEB-INF:WEB-INF目录是J2
  • 我电脑是windows的,前端 WEB 集成开发环境brackets从官网下载后打不开? 在官网上,下的1.7,桌面只有个安装。
  • Go——go web 集成swagger

    千次阅读 2019-07-19 17:29:09
    java中可直接引用swagger依赖,spring全家桶对swagger也集成通过写注解便可直接生成入参返回值的api接口文档。go项目也有对应的swaggo集成。下面介绍如何在go工程中使用swaggo自动生成接口文档。很简单,三步走 一...
  • Shiro提供了与Web集成的支持,其通过一个ShiroFilter入口来拦截需要安全控制的URL,然后进行相应的控制,ShiroFilter类似于如Strut2/SpringMVC这种web框架的前端控制器,其是安全控制的入口点,其负责读取配置(如...
  • 公司的项目要集成海康的摄像头。我相信大多数集成摄像头的情况也就是在自己的项目页面中嵌入摄像头的监控画面或者基本功能,如果太复杂的业务场景海康也给出了不少的平台方案。现在就说集成最基本,更复杂的业务逻辑...
  • Java web集成支付宝电脑支付接口(沙箱环境)

    万次阅读 多人点赞 2017-08-20 23:03:27
    前言 这是博主的第一篇博客,刚刚毕业,打算把...这篇博客主要介绍如何在Java web项目中集成支付宝的电脑支付接口(会稍微介绍一下服务器集成APP支付接口)。目前支付宝接口更新很快,在博主查找资料的时候,很多都是...
  • Java Web 集成RTX问题解决

    千次阅读 2017-08-14 12:13:59
    今天,应项目需求,需要在项目中集成腾讯的RTX。前期根据RTX官方API文档进行测试时,没有任何问题,但是在将代码集成到项目中时,报了一些错误(Init()z、),现将我的解决过程写下来,希望给遇到同样问题的人提供一些...
  • FineReport(一):FineReport与Web集成

    千次阅读 2018-03-15 15:51:50
    一、Web项目集成1、将fineReport安装目录下的jar包全部拷贝到web工程下的lib中(数据库jar只需一个)。2、在web工程WEB-INF下新建两个目录reportlets(存在报表模板文件)和resources(存放数据连接信息)。3、在web...
  • imageUpload: true, imageFormats: ["jpg", "jpeg", "gif", "png", "bmp", "webp"], imageUploadURL: "${basePath}/file/markdownUpload",

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 46,775
精华内容 18,710
关键字:

web集成