精华内容
下载资源
问答
  • 2019-09-05 17:52:22

    ************************************************************
    Python Flask 后台如何获取 URL 提交的 参数?

    方法一用 request.form['username'] 与  request.form['password']

    @app.route('/login', methods=['GET', 'POST'])
    def login():
        username = request.form['username']
        print(username)
        password = request.form['password']
        print(password) 


    方法二:request.args.get    

    from flask import request
    
    @app.route(...)
    def login():
        username = request.args.get('username')
        password = request.args.get('password')
        
    #request.args.get 中,各个参数说明
    from flask import request
    @app.route('/my-route')
    def my_route():
      page = request.args.get('page', default = 1, type = int)
      filter = request.args.get('filter', default = '*', type = str)

     

    更多相关内容
  • gin框架之获取URL参数

    千次阅读 2021-11-18 18:50:00
    gin学习之获取URL参数获取URL参数获取querystring参数获取form参数获取json参数获取path参数参数的绑定 获取URL参数 在前面的学习中,我们已经学会了使用gin框架进行请求的转发、html模板的渲染,以及静态资源的...

    获取URL参数

    在前面的学习中,我们已经学会了使用gin框架进行请求的转发、html模板的渲染,以及静态资源的引入,那么进行我们要进行一系列的参数获取的学习。
    那么这个重要吗?非常重要,非常非常重要!!!
    学过Java的朋友在学习框架的时候也会进行学习路径参数的获取,
    比如,通过一些注解来进行获取参数,例如:RequestParam、PathVariable注解等等。
    那这些都是Java的获取方式,那么我们的go世界是如何获取参数的呢?
    一起来看看吧,超级舒服

    获取querystring参数

    在这里插入图片描述

    • 可以看到哈,这个 wd 就是搜索的参数哈,我们在百度里面搜索修改wd的参数,也能完成一个搜索的功能。
    • 但是我们在前端填写后,如何让后台获取到这个参数呢?

    这里我们给出了 三种获取方式

    	str = c.Query("wd")
    	str := c.DefaultQuery("wd","acwing")  
    	str , ok := c.GetQuery("wd")
    
    • 第一种:尝试获取 wd 的参数,获取不到就是nil
    • 第二种:我们设置了一个默认值,如果没有这个参数那么就会使用默认值代替这个参数
    • 第三种:我们尝试获取 wd 的参数,获取不到会返回一个false,然后我们另外做处理即可!
    • 我们来实战一下!!!

    在这里插入图片描述

    • 我们r.run跑起来看看结果!!!

    在这里插入图片描述

    • 我们通过正常的搜索,完全可以获取参数哈!

    在这里插入图片描述
    在这里插入图片描述

    • 第二个也可以正常处理,当遇到没有参数的时候进行获取默认的参数

    在这里插入图片描述

    • 第三个也可以正常获取参数,没有参数就返回false,我们在false时做特殊处理。
    • 嘿嘿嘿,科科不会怪的我

    获取form参数

    • 这个一般时获取表单的里面的数据,而表单里面的提交,一般都是post请求,所以,我们这个要多写一个函数用于获取post请求。

    那么针对 post请求 ,go也给出了三种同步的方式,聪明的人已经猜到了,没错,和get请求类似,啊哈哈哈哈哈哈

    	username := c.PostForm("username")
    	username = c.DefaultPostForm("username","somebody")
    	username , ok := c.GetPostForm("username")
    
    • 这里我们就用获取用户名来举例子哈!表单一般都有用户名满,啊哈哈哈哈哈哈
    • 用法和楼上差不多,我们就不一一举例子了哈,这里就随便选择一个来实战下哈!

    为了方便我们提交post请求,我们建立两个模板

    用于登录的界面

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>登录页面</title>
    </head>
    <body>
        <form action="/login" method="post">
                <label for="username">username:</label>
                <input type="text" name="username" id="username">
                <input type="submit" value="登录">
        </form>
    </body>
    </html>
    
    • 返回获取post请求参数的界面 ,
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
      <div>
        hello {{ .username }}
      </div>
    </body>
    </html>
    
    • 非常的人性哈!来看看后台代码吧!

    在这里插入图片描述

    • 我们搞好后直接运行看看结果哈!
      在这里插入图片描述
      在这里插入图片描述
    • 点击登录后,即跳转到post请求的模板界面,并将名称参数获取到了!

    我们都知道哈,浏览器里面如果不通过表单的形式进行提交,而直接在url参数提交的话,都是get请求哈,有的小伙伴就是不想这么麻烦,就是想直接测试一下这个接口能不能正确获取对吧,那有木有办法呢?

    答案是有的哈, 我记得前面的文章里面有提到过, postman这个工具哦,可以直接发送post等请求
    我们一起看看吧!
    在这里插入图片描述

    • 可以看到哈,我们也成功的对他们做了测试,并且返回了我们想要看到的数据,工具还是舒服呢

    获取json参数

    • 这个划重点哈,我们前后端数据交互,最常用的格式就是json格式了。
    • 在go里面同样如此,我们go提供了三种方式进行传输json数据
    • mapgin.H结构体 ,来试试看吧

    在这里插入图片描述

    • gin.H有蛮多人看不明白哈,如果你点进源码多看看的话,就会知道,里面其实就是一个map,啊哈哈
    • gin框架就是为了大家方便,封住了下下。然后我们跑起来看看哈!

    在这里插入图片描述

    • 非常的完美和人性哈!!!下一个下一个

    获取path参数

    • 就玩意就是获取路径上面的参数,没有标明emmm举个例子说明吧,感觉文字难以解释
    	http://localhost:9090/index/张三/18
    
    • 看看这个请求哈,这个表示我们发送一个get请求,里面携带了两个参数,18岁的张三,能理解吧!嘿嘿嘿
    • 那么这个我们要如果获取呢?也很简单哈,gin提供了Param方法
    	name := c.Param("name")
    
    • 这样就可以了吗?
    • 怎么可能呢,路径上的写法要发送一丢丢的改变才可以哈!一起来看看吧!

    在这里插入图片描述

    • 路径前面加个冒号 : ,即可哈,跑起来看看效果吧!

    在这里插入图片描述

    • 这也是成功的获取到了哈,非常的舒服
    • 有的小伙伴就问了,这个有啥用呢,我们不是已经有那个获取参数的方法了吗,为什么还要整一个这个呢?
    • 存在即合理,不知道大家有木有看到过有的个人博客网站呀,后面跟的上面 ***/2018/12/4这样的路径哈,可以通过这样保存时间呀,兄弟们。

    参数的绑定

    • 这玩意还是要说说的,如果不搞这个,那我们以后搞项目的时候,参数一多,头就大了,
    • 来看个代码

    在这里插入图片描述

    • 好兄弟们,这个是post请求获取参数,一个一个来呀!
    • 大家都经历过校招吧,去公司官网里面搞简历的时候,那个表单,给人都写吐了,
    • 起码得二三十个参数吧,这总不能一个一个去写这个玩意吧,那不得难受呀,开发人员。
    • 为了不然我们难受哈,我们就来学习参数的绑定。

    首先我们先搞个结构体哈,类似于Java里面的类

    type UserInfo struct {
    	Username string `json:"username" xml:"username" form:"username"`
    	Password string	`json:"password" xml:"password" form:"password"`
    }
    
    • 后面的设置标记,不然就要使用大写,首字母大写,在go里面的表示对外开放权限哦,不然访问不到的呢

    对于装配数据,go也是给了函数的

    	err := c.ShouldBind(&u)
    
    • 就是这个哈,很好记忆吧 , shouldbind,应该绑定绑定,啊哈哈哈哈哈,
    • 特别注意哈 : 里面的参数一定要是结构体的指针哈!!!

    先来发个get请求哈!
    在这里插入图片描述

    • 是的,你没有看错,这就可以了,也不用我们去一个一个去写参数了,直接shouldbind。
    • 来看看效果。
      在这里插入图片描述
    • 非常的完美哈!
    • 我们再来试试post请求吧,毕竟表单才是我们需要搞的重点,谁没事在url填写参数呀,哎嘿嘿

    在这里插入图片描述

    • post请求和get没啥差别哈,搞get是为了方便看效果,毕竟post要制作表格,
    • 但是今天说了 postman 这个工具满,所以我们使用 postman工具 进行测试哈

    在这里插入图片描述

    • 非常的完美和人性哈!

    有木有感觉比Java要舒服,啊哈哈哈哈哈!(手动狗头保命)

    展开全文
  • Form表单提交整个表单需要序列化 serialize()方法 Var formData = $(“#regiseterForm”).serialize() //获取整个表单数据 Map<String, String[]> map = request.getParameterMap(); /User user = new User();...

    Form表单提交整个表单需要序列化

    serialize()方法
    Var formData = $(“#regiseterForm”).serialize()
    //获取整个表单数据
    Map<String, String[]> map = request.getParameterMap();
    /User user = new User();
    //封装结果集的map
    Map<String, Object> result = new HashMap<>();
    /使用BeanUtils工具类,把map中的数据 封装到实体类中
    BeanUtils.populate(user,map);
    

    表单提交用post
    服务器获取数据用get

    <%--内敛表单--%>

    <a class=“btn btn-info” CSS按钮颜色设置
    需要导js
    获取a超链接中href中url传递过来拼接的数值href=route_list.html?cid=’+element.可以获取cid的值

    <script src="js/getParameter.js"></script>
    

    //先获取url = http://localhost:8080/route_list.html?cid=5
    var cid = getParameter(“cid”);
    并发问题多个方法同时请求一个成员变量;
    在这里插入图片描述
    用户登陆成功后必须在Web层把数据保存在session中,不需要返回boolean,需要返回数据.
    Session中存储的的什么类型,获取时必须同样的类型
    Debugger可以放在嵌入的HTML中

    当元素失去焦点时触发 blur 事件。
    这个函数会调用执行绑定到blur事件的所有函数,包括浏览器的默认行为。可以通过返回false来防止触发浏览器的默认行为。blur事件会在元素失去焦点的时候触发,既可以是鼠标行为,也可以是按tab键离开的
    $(“p”).blur();

    展开全文
  • 公司最近做大屏幕数据展示,需要获取svn/git、jira、jenkins、sonar上的数据。本人除了git外,其它工具都不熟,索性网络时代救了我,本人也是查了很多资料来实现自己的项目需求功能。 java获取svn代码,是看到了...

    公司最近做大屏幕数据展示,需要获取svn/git、jira、jenkins、sonar上的数据。本人除了git外,其它工具都不熟,索性网络时代救了我,本人也是查了很多资料来实现自己的项目需求功能。
    java获取svn代码,是看到了scdn上的一位大神杰作来修改的,由于本人的粗心,那位大神的链接地址一时间找不到了。以后看到了一定补上链接,在这里对大神说声抱歉,以下奉上本人修改后的代码。
    大神连接地址https://blog.csdn.net/u012621115/article/details/51851572
    1.获取svn数据所依赖的jar

    		<!--svn获取数据需要jar-->
    		<!-- https://mvnrepository.com/artifact/org.tmatesoft.svnkit/svnkit -->
    		<dependency>
    			<groupId>org.tmatesoft.svnkit</groupId>
    			<artifactId>svnkit</artifactId>
    			<version>1.9.3</version>
    		</dependency>
    		<!--svn获取需要jar完毕-->
    

    2.存入后台版本号、当前版本的总影响行数

    package com.zkr.cxhjcxt.dto;
    
    import com.zkr.cxhjcxt.model.SvnDataAuxiliaryTwo;
    import lombok.Data;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * Created by youzongxu on 2018/9/7.
     */
    @Data
    public class SvnDto {
        private int sum;
        private List<SvnDataAuxiliaryTwo> lists = new ArrayList<>();
        private long version;
    }
    

    3.存入后台版本号、影响行数、文件路径、文件类型

    package com.zkr.cxhjcxt.model;
    
    import lombok.Data;
    
    /**
     * Created by youzongxu on 2018/9/10.
     */
    @Data
    public class SvnDataAuxiliaryTwo extends BaseEntity<Long>{
        private static final long serialVersionUID = -124865218511677256L;
        private Long svnReversion;
        private Integer svnAddlines;
        private String svnFilepath;
        private String svnChangetype;
    }
    

    4.存入后台提交人、版本号、svn信息、提交svn时间

    package com.zkr.cxhjcxt.model;
    
    import lombok.Data;
    
    import java.util.Date;
    
    /**
     * Created by youzongxu on 2018/9/7.
     */
    @Data
    public class SvnData extends BaseEntity<Long>{
        private static final long serialVersionUID = 6041141704397137128L;
        private String author;
        private Long revision;
        private String svnMessage;
        private Date svnTime;
    }
    

    5.后台存入数据、借助的都是下面svn工具类中的方法,这里面的有些数据需要改成自己所用到的

    package com.zkr.cxhjcxt.utils;
    
    import com.google.common.collect.Lists;
    import com.zkr.cxhjcxt.constants.SvnTimeConstants;
    import com.zkr.cxhjcxt.dao.DataConfigurationDao;
    import com.zkr.cxhjcxt.dict.DictConstants;
    import com.zkr.cxhjcxt.dto.SvnDto;
    import com.zkr.cxhjcxt.model.DataConfiguration;
    import com.zkr.cxhjcxt.model.SvnDataAuxiliaryOne;
    import com.zkr.cxhjcxt.model.SvnDataAuxiliaryThree;
    import com.zkr.cxhjcxt.service.SvnDataService;
    import com.zkr.cxhjcxt.service.SysLogService;
    import com.zkr.cxhjcxt.timedutils.svnutil;
    import lombok.extern.slf4j.Slf4j;
    
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.List;
    import java.util.Map;
    
    /**
     *
     * @author youzongxu
     * @date 2018/9/12
     */
    @Slf4j
    public class SvnUtil {
    
        public void SvnUtil(){
            //获取1:请求路径2:账号3:密码
            DataConfigurationDao dataConfigurationDao = SpringUtil.getBean(DataConfigurationDao.class);
            List<DataConfiguration> svnget = dataConfigurationDao.dataGetSvn(DictConstants.SVN_DICT);
            if(null != svnget){
                Date now = new Date();
                SvnDataService svnDataService = SpringUtil.getBean(SvnDataService.class);
                List<SvnDto> lists = Lists.newArrayList();
                int today = 0;
                int sevenToday = 0;
                int thirtyToday = 0;
                int nows = 0;
                int ones = 0;
                int twos = 0;
                int threes = 0;
                int fours = 0;
                int fives = 0;
                int sixs = 0;
                int sevens = 0;
                for (DataConfiguration ls:svnget) {
                    Date daysago = new Date(now.getTime()-convertDaysToMilliseconds(Integer.parseInt(ls.getTimeFrame())));
                    //启动
                    svnutil svn = new svnutil(ls.getDataUsername(),ls.getDataPassword(),ls.getDataUrl());
                    try {
                        //主表数据保存
                        List<SvnDto> svnDtos = svn.staticticsCodeAddByTime(now, fm(daysago));
                        lists.addAll(svnDtos);
                        //辅表数保存
                        Map<String, Object> map = svn.commitCount();
                        today += Integer.parseInt(map.get("today").toString());
                        sevenToday += Integer.parseInt(map.get("sevenToday").toString());
                        thirtyToday += Integer.parseInt(map.get("thirtyToday").toString());
    
                        Map<String, Object> map1 = svn.dmCount();
                        nows += Integer.parseInt(map1.get("now").toString());
                        ones += Integer.parseInt(map1.get("one").toString());
                        twos += Integer.parseInt(map1.get("two").toString());
                        threes += Integer.parseInt(map1.get("three").toString());
                        fours += Integer.parseInt(map1.get("four").toString());
                        fives += Integer.parseInt(map1.get("five").toString());
                        sixs += Integer.parseInt(map1.get("six").toString());
                        sevens += Integer.parseInt(map1.get("seven").toString());
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
                List<SvnDataAuxiliaryOne> svnDataAuxiliaryOnes = getSvnDataAuxiliaryOnes(today, sevenToday, thirtyToday);
                List<SvnDataAuxiliaryThree> svnDataAuxiliaryThrees = getSvnDataAuxiliaryThrees(nows, ones, twos, threes, fours, fives, sixs, sevens);
                svnDataService.saveData(lists);
                svnDataService.saveCommitCount(svnDataAuxiliaryOnes);
                svnDataService.saveWeekCommitCount(svnDataAuxiliaryThrees);
            }
        }
    
        private List<SvnDataAuxiliaryThree> getSvnDataAuxiliaryThrees(int nows, int ones, int twos, int threes, int fours, int fives, int sixs, int sevens) {
            List<SvnDataAuxiliaryThree> ls = Lists.newArrayList();
            SvnDataAuxiliaryThree svnDataAuxiliaryThree = new SvnDataAuxiliaryThree();
            SvnDataAuxiliaryThree svnDataAuxiliaryThree1 = new SvnDataAuxiliaryThree();
            SvnDataAuxiliaryThree svnDataAuxiliaryThree2 = new SvnDataAuxiliaryThree();
            SvnDataAuxiliaryThree svnDataAuxiliaryThree3 = new SvnDataAuxiliaryThree();
            SvnDataAuxiliaryThree svnDataAuxiliaryThree4 = new SvnDataAuxiliaryThree();
            SvnDataAuxiliaryThree svnDataAuxiliaryThree5 = new SvnDataAuxiliaryThree();
            SvnDataAuxiliaryThree svnDataAuxiliaryThree6 = new SvnDataAuxiliaryThree();
            SvnDataAuxiliaryThree svnDataAuxiliaryThree7 = new SvnDataAuxiliaryThree();
    
            svnDataAuxiliaryThree.setName(SvnTimeConstants.Today);
            svnDataAuxiliaryThree.setSum(nows);
            svnDataAuxiliaryThree1.setName(SvnTimeConstants.ONE);
            svnDataAuxiliaryThree1.setSum(ones);
            svnDataAuxiliaryThree2.setName(SvnTimeConstants.TWO);
            svnDataAuxiliaryThree2.setSum(twos);
            svnDataAuxiliaryThree3.setName(SvnTimeConstants.THREE);
            svnDataAuxiliaryThree3.setSum(threes);
            svnDataAuxiliaryThree4.setName(SvnTimeConstants.FOUR);
            svnDataAuxiliaryThree4.setSum(fours);
            svnDataAuxiliaryThree5.setName(SvnTimeConstants.FIVE);
            svnDataAuxiliaryThree5.setSum(fives);
            svnDataAuxiliaryThree6.setName(SvnTimeConstants.SIX);
            svnDataAuxiliaryThree6.setSum(sixs);
            svnDataAuxiliaryThree7.setName(SvnTimeConstants.SEVEN);
            svnDataAuxiliaryThree7.setSum(sevens);
    
            ls.add(svnDataAuxiliaryThree);
            ls.add(svnDataAuxiliaryThree1);
            ls.add(svnDataAuxiliaryThree2);
            ls.add(svnDataAuxiliaryThree3);
            ls.add(svnDataAuxiliaryThree4);
            ls.add(svnDataAuxiliaryThree5);
            ls.add(svnDataAuxiliaryThree6);
            ls.add(svnDataAuxiliaryThree7);
            return ls;
        }
    
        private List<SvnDataAuxiliaryOne> getSvnDataAuxiliaryOnes(int today, int sevenToday, int thirtyToday){
            List<SvnDataAuxiliaryOne> ls = Lists.newArrayList();
            SvnDataAuxiliaryOne svnDataAuxiliaryOne = new SvnDataAuxiliaryOne();
            svnDataAuxiliaryOne.setName(SvnTimeConstants.Today);
            svnDataAuxiliaryOne.setSum(today);
            SvnDataAuxiliaryOne svnDataAuxiliaryOne1 = new SvnDataAuxiliaryOne();
            svnDataAuxiliaryOne1.setName(SvnTimeConstants.Nearlysevendays);
            svnDataAuxiliaryOne1.setSum(sevenToday);
            SvnDataAuxiliaryOne svnDataAuxiliaryOne2 = new SvnDataAuxiliaryOne();
            svnDataAuxiliaryOne2.setName(SvnTimeConstants.NearlyThirtydays);
            svnDataAuxiliaryOne2.setSum(thirtyToday);
            ls.add(svnDataAuxiliaryOne);
            ls.add(svnDataAuxiliaryOne1);
            ls.add(svnDataAuxiliaryOne2);
            return ls;
        }
    
        public long convertDaysToMilliseconds (int days){
            return 1000L*3600*24*days;
        }
    
        public Date fm(Date daysago){
            try {
                SimpleDateFormat sdf=new SimpleDateFormat(SvnTimeConstants.fm);
                Date parse = sdf.parse(sdf.format(daysago));
                return parse;
            } catch (ParseException e) {
                e.printStackTrace();
            }
            return daysago;
        }
    }
    

    6.svn工具类、需要把userName 、password 、urlString 更换称自己的、我是直接从后台数据库中获取的,自己可以写个main方法测试下。

    package com.zkr.cxhjcxt.timedutils;
    
    import com.google.common.collect.Lists;
    import com.google.common.collect.Maps;
    import com.zkr.cxhjcxt.constants.SvnTimeConstants;
    import com.zkr.cxhjcxt.dto.ChangeFile;
    import com.zkr.cxhjcxt.dto.SvnDto;
    import com.zkr.cxhjcxt.model.*;
    import lombok.extern.slf4j.Slf4j;
    import org.apache.commons.lang3.StringUtils;
    import org.joda.time.DateTime;
    import org.joda.time.LocalDate;
    import org.springframework.util.CollectionUtils;
    import org.tmatesoft.svn.core.*;
    import org.tmatesoft.svn.core.auth.ISVNAuthenticationManager;
    import org.tmatesoft.svn.core.internal.wc.DefaultSVNOptions;
    import org.tmatesoft.svn.core.io.SVNRepository;
    import org.tmatesoft.svn.core.io.SVNRepositoryFactory;
    import org.tmatesoft.svn.core.wc.SVNDiffClient;
    import org.tmatesoft.svn.core.wc.SVNLogClient;
    import org.tmatesoft.svn.core.wc.SVNRevision;
    import org.tmatesoft.svn.core.wc.SVNWCUtil;
    
    import java.io.*;
    import java.util.*;
    
    /**
     * svn获取
     *
     * @author youzongxu
     * @date 2018/9/7
     */
    @Slf4j
    public class svnutil {
        private String userName = "";
        private String password = "";
        private String urlString = "";
        /**
         * 临时文件
         */
        private String tempDir = System.getProperty("java.io.tmpdir");
        private DefaultSVNOptions options = SVNWCUtil.createDefaultOptions(true);
        private Random random = new Random();
    
        private SVNRepository repos;
        private ISVNAuthenticationManager authManager;
    
        public svnutil(String u,String p,String url) {
            try {
                userName = u;
                password = p;
                urlString = url;
                init();
            } catch (SVNException e) {
                e.printStackTrace();
            }
        }
    
        public void init() throws SVNException{
            log.info("开始加载");
            authManager = SVNWCUtil.createDefaultAuthenticationManager(new File(tempDir+"/auth"), userName, password.toCharArray());
            options.setDiffCommand("-x -w");
            repos = SVNRepositoryFactory.create(SVNURL
                    .parseURIEncoded(urlString));
            repos.setAuthenticationManager(authManager);
            log.info("init completed");
        }
    
        /**
         * 统计一段时间内代码增加量
         * @param st
         * @param et
         * @return
         * @throws Exception
         */
        public List<SvnDto> staticticsCodeAddByTime(Date st, Date et) throws Exception{
            SVNLogEntry[] logs = getLogByTime(st, et);
            List<SvnDto> ls = Lists.newArrayList();
            if(logs.length > 0){
                for(SVNLogEntry log:logs){
                    File logFile = getChangeLog(log.getRevision(), log.getRevision()-1);
                    SvnDto svnDto = new SvnDto();
                    svnDto.setAuthor(log.getAuthor());
                    svnDto.setRevision(log.getRevision());
                    svnDto.setSvnMessage(StringUtils.isNotBlank(log.getMessage())?log.getMessage():SvnTimeConstants.SvnMessageFlag);
                    svnDto.setSvnTime(log.getDate());
                    ls.add(svnDto);
                    List<SvnDataAuxiliaryFour> fourList = getChangeFileList(log.getRevision());
                    List<SvnDataAuxiliaryTwo> twoList = staticticsCodeAdd(logFile, log.getRevision());
                    if(!CollectionUtils.isEmpty(fourList)){
                        svnDto.setFourList(fourList);
                    }
                    if(!CollectionUtils.isEmpty(twoList)){
                        svnDto.setTwoList(twoList);
                    }
                }
            }
            return ls;
        }
    
        /**获取某一版本有变动的文件路径
         * @param version
         * @return
         * @throws SVNException
         */
        public List<SvnDataAuxiliaryFour> getChangeFileList(long version) throws SVNException{
            List<SvnDataAuxiliaryFour> ls = Lists.newArrayList();
            SVNLogClient logClient = new SVNLogClient( authManager, options );
            SVNURL url = SVNURL.parseURIEncoded(urlString);
            String[] paths = { "." };
            SVNRevision pegRevision = SVNRevision.create( version );
            SVNRevision startRevision = SVNRevision.create( version );
            SVNRevision endRevision = SVNRevision.create( version );
            long limit = 9999L;
            ISVNLogEntryHandler handler = new ISVNLogEntryHandler() {
                /**
                 * This method will process when doLog() is done
                 */
                @Override
                public void handleLogEntry( SVNLogEntry logEntry ) {
                    Map<String, SVNLogEntryPath> maps = logEntry.getChangedPaths();
                    Set<Map.Entry<String, SVNLogEntryPath>> entries = maps.entrySet();
                    for(Map.Entry<String, SVNLogEntryPath> entry : entries){
                        SvnDataAuxiliaryFour svnDataAuxiliaryFour = new SvnDataAuxiliaryFour();
                        svnDataAuxiliaryFour.setSvnVersion(logEntry.getRevision());
                        svnDataAuxiliaryFour.setSvnPath(entry.getValue().getPath());
                        svnDataAuxiliaryFour.setSvnType(String.valueOf(entry.getValue().getType()));
                        ls.add(svnDataAuxiliaryFour);
                    }
                }
            };
            try {
                logClient.doLog( url, paths, pegRevision, startRevision, endRevision, false, true, limit, handler );
            }
            catch ( SVNException e ) {
                System.out.println( "Error in doLog() " );
                e.printStackTrace();
            }
            return ls;
        }
    
        /**获取一段时间内,所有的commit记录
         * @param st	开始时间
         * @param et	结束时间
         * @return
         * @throws SVNException
         */
        public SVNLogEntry[] getLogByTime(Date st, Date et) throws SVNException{
            long startRevision = repos.getDatedRevision(st);
            long endRevision = repos.getDatedRevision(et);
            @SuppressWarnings("unchecked")
            Collection<SVNLogEntry> logEntries = repos.log(new String[]{""}, null,
                    startRevision, endRevision, true, true);
            SVNLogEntry[] svnLogEntries = logEntries.toArray(new SVNLogEntry[0]);
            SVNLogEntry[] svnLogEntries1 = Arrays.copyOf(svnLogEntries, svnLogEntries.length - 1);
            return svnLogEntries1;
        }
    
    
        /**获取版本比较日志,并存入临时文件
         * @param startVersion
         * @param endVersion
         * @return
         */
        public File getChangeLog(long startVersion, long endVersion) {
            SVNDiffClient diffClient = new SVNDiffClient(authManager, options);
            diffClient.setGitDiffFormat(true);
            File tempLogFile;
            OutputStream outputStream = null;
            String svnDiffFile;
            do {
                svnDiffFile = tempDir + "/svn_diff_file_"+startVersion+"_"+endVersion+"_"+random.nextInt(10000)+".txt";
                tempLogFile = new File(svnDiffFile);
            } while (tempLogFile != null && tempLogFile.exists());
            try {
                tempLogFile.createNewFile();
                outputStream = new FileOutputStream(svnDiffFile);
                diffClient.doDiff(SVNURL.parseURIEncoded(urlString),
                        SVNRevision.create(startVersion),
                        SVNURL.parseURIEncoded(urlString),
                        SVNRevision.create(endVersion),
                        SVNDepth.UNKNOWN, true, outputStream);
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                if(outputStream!=null) {
                    try {
                        outputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            return tempLogFile;
        }
    
        /**分析变更的代码,统计代码增量
         * @param file
         * @param revision
         * @return
         * @throws Exception
         */
        public List<SvnDataAuxiliaryTwo> staticticsCodeAdd(File file, long revision) throws Exception{
            log.info("开始统计修改代码行数");
            List<SvnDataAuxiliaryTwo> twoList = Lists.newArrayList();
            FileReader fileReader = new FileReader(file);
            BufferedReader in = new BufferedReader(fileReader);
            String line;
            StringBuffer buffer = new StringBuffer(1024);
            boolean start = false;
            while((line=in.readLine()) != null){
                if(line.startsWith("Index:")){
                    if(start){
                        ChangeFile changeFile = parseChangeFile(buffer);
                        if(null!=changeFile){
                            String filePath = changeFile.getFilePath();
                            if(getBoolean(filePath)){
                                int oneSize = staticOneFileChange(changeFile);
                                SvnDataAuxiliaryTwo svnDataAuxiliaryTwo = new SvnDataAuxiliaryTwo();
                                svnDataAuxiliaryTwo.setSvnAddlines(oneSize);
                                svnDataAuxiliaryTwo.setSvnFilepath("/"+changeFile.getFilePath());
                                svnDataAuxiliaryTwo.setSvnReversion(revision);
                                twoList.add(svnDataAuxiliaryTwo);
                            }
                        }
                        buffer.setLength(0);
                    }
                    start = true;
                }
                buffer.append(line).append('\n');
            }
            if(buffer.length() > 0){
                ChangeFile changeFile = parseChangeFile(buffer);
                if(null!=changeFile){
                    String filePath = changeFile.getFilePath();
                    if(getBoolean(filePath)){
                        int oneSize = staticOneFileChange(changeFile);
                        SvnDataAuxiliaryTwo svnDataAuxiliaryTwo = new SvnDataAuxiliaryTwo();
                        svnDataAuxiliaryTwo.setSvnAddlines(oneSize);
                        svnDataAuxiliaryTwo.setSvnFilepath("/"+changeFile.getFilePath());
                        svnDataAuxiliaryTwo.setSvnReversion(revision);
                        twoList.add(svnDataAuxiliaryTwo);
                    }
                }
            }
            in.close();
            fileReader.close();
            boolean deleteFile = file.delete();
            log.info("-----delete file-----"+deleteFile);
            return twoList;
        }
    
        public boolean getBoolean(String filePath){
            String[] k = {".java", ".html", ".css", ".js", ".jsp", ".properties",".xml",".json",".sql",".wxml",".wxss"};
            List<String> strings = Arrays.asList(k);
            boolean ba = false;
            c:for (String ls:strings) {
                if(filePath.contains(ls)){
                    ba = true;
                    break c;
                }
            }
            return ba;
        }
    
        /**统计单个文件的增加行数,(先通过过滤器,如文件后缀、文件路径等等),也可根据修改类型来统计等,这里只统计增加或者修改的文件
         * @param changeFile
         * @return
         */
        public int staticOneFileChange(ChangeFile changeFile){
            char changeType = changeFile.getChangeType();
            char A = 'A';
            char M = 'M';
            if(A == changeType){
                return countAddLine(changeFile.getFileContent());
            }else if(M == changeType){
                return countAddLine(changeFile.getFileContent());
            }
            return 0;
        }
    
        /**解析单个文件变更日志:A表示增加文件,M表示修改文件,D表示删除文件,U表示末知
         * @param str
         * @return
         */
        public ChangeFile parseChangeFile(StringBuffer str){
            int index = str.indexOf("\n@@");
            if(index > 0){
                String header = str.substring(0, index);
                String[] headers = header.split("\n");
                String filePath = "";
                if(StringUtils.isNotBlank(headers[0])){
                    filePath = headers[0].substring(7);
                }
                char changeType = 'U';
                boolean oldExist = !headers[2].endsWith("(nonexistent)");
                boolean newExist = !headers[3].endsWith("(nonexistent)");
                if(oldExist && !newExist){
                    changeType = 'D';
                }else if(!oldExist && newExist){
                    changeType = 'A';
                }else if(oldExist && newExist){
                    changeType = 'M';
                }
                int bodyIndex = str.indexOf("@@\n")+3;
                String body = str.substring(bodyIndex);
                if(StringUtils.isNotBlank(filePath)){
                    ChangeFile changeFile = new ChangeFile(filePath, changeType, body);
                    return changeFile;
                }
            }else{
                String[] headers = str.toString().split("\n");
                log.info("headers"+headers[0]);
                if(StringUtils.isNotBlank(headers[0])){
                    String filePath = headers[0].substring(7);
                    ChangeFile changeFile = new ChangeFile(filePath, 'U', null);
                    return changeFile;
                }
            }
            return null;
        }
    
    
        /**通过比较日志,统计以+号开头的非空行
         * @param content
         * @return
         */
        public int countAddLine(String content){
            int sum = 0;
            if(content !=null){
                content = '\n' + content +'\n';
                char[] chars = content.toCharArray();
                int len = chars.length;
                //判断当前行是否以+号开头
                boolean startPlus = false;
                //判断当前行,是否为空行(忽略第一个字符为加号)
                boolean notSpace = false;
                for(int i=0;i<len;i++){
                    char ch = chars[i];
                    if(ch =='\n'){
                        //当当前行是+号开头,同时其它字符都不为空,则行数+1
                        if(startPlus && notSpace){
                            sum++;
                            notSpace = false;
                        }
                        //为下一行做准备,判断下一行是否以+头
                        if(i < len-1 && chars[i+1] == '+'){
                            startPlus = true;
                            //跳过下一个字符判断,因为已经判断了
                            i++;
                        }else{
                            startPlus = false;
                        }
                    }else if(startPlus && ch > ' '){
                        //如果当前行以+开头才进行非空行判断
                        notSpace = true;
                    }
                }
            }
            return sum;
        }
    
    
        /**
         * 获取提交次数
         * @param dt
         * @return
         */
        public int countSum(Date dt){
            try {
                Date now = new Date();
                SVNLogEntry[] logByTime = getLogByTime(now, dt);
                List<SVNLogEntry> svnLogEntries = Arrays.asList(logByTime);
                return svnLogEntries.size();
            } catch (SVNException e) {
                return 0;
            }
        }
    
        /**
         * 获取提交量
         * @param dt
         * @return
         */
        public int dmCountSum(Date dt){
            int sum = 0;
            try {
                Date now = new Date();
                SVNLogEntry[] logByTime = getLogByTime(now, dt);
                List<SVNLogEntry> svnLogEntries = Arrays.asList(logByTime);
                sum = 0;
                for (SVNLogEntry ls:svnLogEntries) {
                    sum += ls.getChangedPaths().size();
                }
            } catch (SVNException e) {
                e.printStackTrace();
            }
            return sum;
        }
    
    
        /**
         * 获取:1:今天 2:近一周 3:近一个月的数据
         * @return
         */
        public Map<String,Object> commitCount(){
            LocalDate localDate = new DateTime().toLocalDate();
            LocalDate localDateSeven = new DateTime().minusDays(SvnTimeConstants.seven).toLocalDate();
            LocalDate localDateThirty = new DateTime().minusDays(SvnTimeConstants.Thirty).toLocalDate();
            int today = countSum(localDate.toDate());
            int sevenToday = countSum(localDateSeven.toDate());
            int thirtyToday = countSum(localDateThirty.toDate());
            Map<String,Object> map = Maps.newHashMap();
            map.put("today",today);
            map.put("sevenToday",sevenToday);
            map.put("thirtyToday",thirtyToday);
            return map;
        }
    
        public Map<String,Object> dmCount(){
            Map<String,Object> map = Maps.newHashMap();
            //日期改成时间排列
            LocalDate now = new DateTime().toLocalDate();
            LocalDate one = new DateTime().minusDays(SvnTimeConstants.one).toLocalDate();
            LocalDate two = new DateTime().minusDays(SvnTimeConstants.two).toLocalDate();
            LocalDate three = new DateTime().minusDays(SvnTimeConstants.three).toLocalDate();
            LocalDate four = new DateTime().minusDays(SvnTimeConstants.four).toLocalDate();
            LocalDate five = new DateTime().minusDays(SvnTimeConstants.five).toLocalDate();
            LocalDate six = new DateTime().minusDays(SvnTimeConstants.six).toLocalDate();
            LocalDate seven = new DateTime().minusDays(SvnTimeConstants.seven).toLocalDate();
    
            int now_count = dmCountSum(now.toDate());
            int one_count = dmCountSum(one.toDate())-now_count;
            int two_count = dmCountSum(two.toDate())-one_count;
            int three_count = dmCountSum(three.toDate())-two_count;
            int four_count = dmCountSum(four.toDate())-three_count;
            int five_count = dmCountSum(five.toDate())-four_count;
            int six_count = dmCountSum(six.toDate())-five_count;
            int seven_count = dmCountSum(seven.toDate())-six_count;
    
            map.put("now",now_count);
            map.put("one",one_count);
            map.put("two",two_count);
            map.put("three",three_count);
            map.put("four",four_count);
            map.put("five",five_count);
            map.put("six",six_count);
            map.put("seven",seven_count);
            return map;
        }
    }
    
    展开全文
  • vue 获取url里参数的两种方法小结

    万次阅读 2020-12-28 23:13:46
    vue 获取url里参数的两种方法小结我就废话不多说了,大家还是直接看代码吧~第一种:const query = Qs.parse(location.search.substring(1))let passport = query.passport;第二种:var query=this.$route.query;let ...
  • 【post提交的数据有哪几种编码格式?能否通过URL参数获取用户账户密码】 每篇分享文从 【背景介绍】【知识剖析】【常见问题】【解决方案】【编码实战】【扩展思考】【更多讨论】【参考文献】 八个方面深度解析...
  • thinkphp5获取URL信息

    千次阅读 2019-02-14 14:55:18
    如果要获取当前的请求信息,可以使用\think\Request类, 除了下文中的 $request = Request::instance(); 也可以使用助手函数 ...获取URL信息 $request = Request::instance(); // 获取当前域名 ec...
  • Ajax获取url返回的数据

    千次阅读 2019-04-20 09:57:08
    背景: (SSM框架)在前台js脚本中获取url返回的值,获取后台的值有多种方式,例如model和modelview都可以在controller层向指定页面传值,前提是它们都得重定向到指定页面,那么就会出现一个问题:在jsp页面JS的...
  • 后端获取URL和参数

    万次阅读 2018-06-14 10:40:33
    一:获取URL 1.Request.getRequestURL 返回的是请求的全部,包括http协议、端口号、servlet名字和映射路径,但不包含请求参数。 结果:http://localhost:8080/jqueryWeb/resources/request.html 2.Request....
  • form表单数据的提交获取

    千次阅读 2022-03-25 10:38:38
    最近写项目遇到的情况,搜索查看以后总结了一下关于form表单的提交与数据获取的方式。 form表单的提交方式: 1.type=submit提交 input type="submit",浏览器显示为button按钮,点击提交表单数据跳转到/url.do &...
  • 记录一下laravel获取url的几个方法

    千次阅读 2018-12-20 18:48:58
    1、URL类和url()辅助方法:  // 获取当前页面的地址(包括get参数) URL::full(); url()-&gt;full(); // 获取当前页面路径 URL::current(); url()-&gt;current(); // 获取上一个页面的地址 URL::previous...
  • 如何使用JGIT在远程仓库获取提交详情记录

    千次阅读 热门讨论 2019-07-16 10:46:58
    本人工作需要,所以学习了一下JGIT的基本使用,本文介绍了如何在eclipse中使用JGIT来获取远程仓库的日志记录,初期学习,如有错误请多多指教
  • Html 原生获取表单提交数据 // 提示框 淡入淡出 <style type="text/css"> .message { display: none; padding: 20px; position: fixed; top: 40%; left: 40%; border-radius: 5px; background: ...
  • 如何获取请求类 获取用户请求信息 获取请求模块\控制器\方法 获取请求相关类型 获取地址栏变量 变量过滤 变量的排除和获取 变量修饰符 更改变量 请求类型判断 模拟put、delete请求 模拟ajax请求和Pjax请求 伪静态 ...
  • 前端程序员做项目的时候会涉及到页面跳转需要传递参数,通常都是将使用post和get方法将数据参数提交到后台,然后再获取。本文提供一种只在前端就能获取页面链接参数的方法,很简单实用。正则分析法:function get...
  • springboot获取URL请求参数的几种方法

    千次阅读 2020-11-03 17:23:44
    1、直接把表单的参数写在Controller相应的方法的形参中,适用于get方式提交,不适用于post方式提交。 /** * 1.直接把表单的参数写在Controller相应的方法的形参中 * @param username * @param password * @...
  • URL获取数据的几种方式

    千次阅读 2018-09-05 14:34:00
    因此,当你确定 URL 指向的绝对是文本且编码格式为ASCII时,使用 openStream()方法比较方便,除此之外,就用 openConnection()方法吧。   下面是url.openStream()的源码: public final InputStream ...
  • Controller获取URL中的参数

    千次阅读 2019-09-05 17:02:41
    文章目录背景正文直接把表单的参数写在Controller相应的方法的...(不推荐)用request.getQueryString() 获取spring MVC get请求的参数,只适用get请求提问 背景 在使用REST接口的时候,需要传递多个参数,遵循REST的...
  • 问题描述一般的form表单提交是单向的:只能给服务器发送数据,但是无法获取服务器返回的数据,也就是无法读取HTTP应答包。想要真正的半双工通讯一般需要使用Ajax, 但是Ajax对文件传输也很麻烦。解决方法方法一:...
  • 本文主要介绍通过gitlab ci获取提交记录,涉及到git log已经gitlab ci.yml的语法以及钉钉接口推送的使用,都是基础知识点,在配置gitlab ci会容易出现问题,无太高难度的事情; 谢谢大家~
  • Java通过URL 从web服务端获取数据

    千次阅读 2018-08-16 14:24:52
    1、Java 通过HttpURLConnection Post方式提交json,并从服务端返回json数据 package Demo.Test; import java.io.ByteArrayOutputStream; import java.io.InputStream; import java.io.OutputStream; import java...
  • 在win7用户遇到ie浏览器无法浏览网页,提示您所请求的网址(url)无法获取,碰到这样的问题该如何处理呢,接下来随win7之家小编一起来看看具体的1、网络设置的问题这种原因比较多出现在需要手动指定IP、网关、2、DNS...
  • 一般的form表单提交是单向的:只能给服务器发送数据,但是无法获取服务器返回的数据,也就是无法读取HTTP应答包。 想要真正的半双工通讯一般需要使用Ajax, 但是Ajax对文件传输也很麻烦。 解决方法 1、使用 JQuery ...
  • 一、下面为7种服务端获取前端传过来的参数的方法 常用的方法为:@RequestParam和@RequestBody 1、直接把表单的参数写在Controller相应的方法的形参中,适用于get方式提交,不适用于post方式提交。 /** * 1.直接把...
  • $currentUrl = $this->helper('core/url')->getCurrentUrl();   //在社会化分享中,当前页面的URL地址非常有用 "helper('core/url')->getCurrentUrl(); ?>">Share on Facebook
  • Spring MVC获取URL参数及请求参数

    万次阅读 2018-07-24 11:40:52
    URL中包含有多层级的路径参数,callback是在service后的一级请求地址(目录),callback后的都是数字都是对应服务器要获取的参数,那么获取这些请求路径部分里的参数则应该列顺序表示层次关系,请求的...
  •  现将过程总结如下(按照我的尝试步骤记录)1.(相对路径)直接将URL和文件地址写到action里用这种所谓的”相对路径“方法得到的浏览器URL的结果为显然不对,这是基于本地根目录的地址的跳转。2...
  • 在日常工作中或浏览网页时,我们经常使用和看到很多表单提交的功能与样式。而这个功能是用form表单和一些JavaScript或jQuery来实现的。 现在我们就用Visual Studio 2015 来对其来进行验证,form表单实现数据获取的...
  • js获取form的值提交

    千次阅读 2015-11-05 10:40:09
    form体使用summit按钮提交会自动发送form里的input等参数。... 我们使用js进行form体提交时 除了逐个获取input的值外 还可以使用如下方法: jsp页面: 名称 - 星级筛选 - 1 2 3 4 5
  • 如果访问时需要获取cid的参数可以参照如下方式: &lt;script src="js/getParameter.js"&gt;&lt;/script&gt; &lt;script&gt; $(function () { var search = locatio...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 412,555
精华内容 165,022
关键字:

如何获取提交网站url