因为在项目中用maven构建项目的时候,有时候需要更换这个文件才可以下载相应的依赖。
重新装一遍插件,虽然破,pom文件写了依赖,但是没编译,编译器不知道这些方法,所以要安装这个插件
通过读取前端传来的值,放BufferedReader里,通过IOUtils,读取处理成字符串处理。
public JsonBean getHook(HttpServletRequest request, HttpServletResponse response) throws Exception{
BufferedReader reader= new BufferedReader(new InputStreamReader(request.getInputStream()));
String body = IOUtils.read(reader);
@Autowire和@Resource都是Spring支持的注解方式动态装配bean。
作用范围在字段上,均无需在写setter方法
这个操作可以监听当你的项目有push或者mergerequest等事件发生的时候,可以向你设定的一个接口发送请求,传相应的信息,然后这个接口可以获取到这个信息,做下一步操作。比如同步变更,两个项目,别人项目中搭建了webhook,当有push操作,发送请求到你的接口,你的项目中也要做相应变更,比如数据库信息同步,就是通过这个信息去调用gitlabAPI获取别人push的sql文件然后同步到自己项目中。
就是项目设置里面搭建,然后你测试本地接口的时候可能要搭建内网穿透,相当于把本地项目放到外网跑起来了,这样你设置的那个hook才可以跳转到把你的接口上去。
这是数据请求的模拟数据
这个网站就是免费搭建的内网穿透,教程就不出了,网站有很简单,我第一次接触6min就搞定了。、
>
>com.alibaba >
>druid >
>1.0.19 >
>
//从sql中读取字段和值
private static void getClounmValue(String sql,List<String> columns,List<String> values) {
MySqlStatementParser parser = new MySqlStatementParser(sql);
SQLStatement sqlStatement = parser.parseStatement();
MySqlInsertStatement insertStatement = (MySqlInsertStatement) sqlStatement;
//获取列的名称,这里用了一个方法将我们的sqlExpr对象转化为String
List<SQLExpr> columnExprs = insertStatement.getColumns();
columns.addAll(sqlExpr2String(columnExprs));
//获取插入的值 这里用了一个方法将我们的sqlExpr对象转化为String
List<SQLInsertStatement.ValuesClause> valuesClauseList = insertStatement.getValuesList();
List<SQLExpr> valueSqlexpr = valuesClauseList.get(0).getValues();
values.addAll( sqlExpr2String(valueSqlexpr));
}
//sqlexpr转String
public static List<String> sqlExpr2String(List<SQLExpr> columnExprs){
StringBuffer sb = new StringBuffer();
List<String> list = new ArrayList<String>();
for(SQLExpr expr:columnExprs){
expr.output(sb);
list.add(sb.toString());
sb.delete(0,sb.length());
}
return list;
}
<!-- maven json解析工具 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.62</version>
</dependency>
JSONObject json = JSONObject.parseObject(val);
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import java.util.Map;
public class JsonDemo {
public static void main(String[] args) {
//1.json字符串转换为对象
String jsonString="{'name':'42313123','id':'2345','age':12}";
JSONObject jsonObject = JSONObject.parseObject(jsonString);
String id = jsonObject.getString("id");
System.out.println(id);
//2. JSONObject转化成自定义类对象
PeoplePo peoplePo1 = JSONObject.parseObject(jsonString, PeoplePo.class);
System.out.println(peoplePo1);
//3. JSONObject转化成Map集合
Map map = JSONObject.parseObject(jsonString, Map.class);
System.out.println(map);
//4. 自定义对象转化成json格式的字符串
PeoplePo peoplePo = new PeoplePo();
peoplePo.setId("1");
peoplePo.setAge(11);
peoplePo.setName("LH");
String peopleJson = JSON.toJSONString(peoplePo);
System.out.println(peopleJson);
//5. String类型转化成JSONObject;
String str = "{\"result\":\"success\",\"message\":\"成功!\"}";
JSONObject jsonObject1 = JSONObject.parseObject(str);
System.out.println(jsonObject1);
//6. JSONObject转化成JSONArray的两种方式
String str1 = "{\"result\":\"success\",\"message\":\"成功!\",\"data\":[{\"name\":\"Tom\",\"age\":\"20\"}]}";
JSONObject jsonToArray = JSONObject.parseObject(str1);
//方式一
JSONArray data = jsonToArray.getJSONArray("data");
System.out.println(data);
//方式二
JSONArray jsonArray = JSONArray.parseArray(jsonToArray.getString("data"));
System.out.println(jsonArray);
//7. jsonArray转化成JSONObject并取出其中的元素数据
JSONObject o = (JSONObject) jsonArray.get(0);
String name = o.getString("name");
System.out.println(o);
System.out.println(name);
System.out.println(jsonArray.toString());
}
}
文件上传后需要读取文件;但是又不想在硬盘存取文件。
public static BufferedReader multipartFileToBufferedReader(MultipartFile picFile, String charsetName) {
// 判断是否为空
if (picFile.isEmpty()) {
return null;
}
try {
InputStream inputStream = picFile.getInputStream();
InputStreamReader is = new InputStreamReader(inputStream, charsetName);
BufferedReader br = new BufferedReader(is);
// String s = "";
// while ((s = br.readLine()) != null) {
// //转成流文件后,就可以自己处理了
// log.info("s="+s);
// }
return br;
} catch (Exception e) {
log.error(e.getMessage(), e);
}
return null;
}
在java中写了对应的type为TextArea,结果就出类型不匹配的错了,后来改成String,好了
在xml文件中不使用resultType(问题很多),而是使用resultMap
>
>
>
>
>
>
>
>
>
>
有些時候,时间是字符串,或者时间格式很奇怪比如带T,所以要先处理下才能比较
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date dateI = format.parse(dealDate(sqlList.get(i).get("timestamp")));
Date dateJ = format.parse(dealDate(sqlList.get(j).get("timestamp")));
if (dateI.before(dateJ)) {
sqlList.remove(i);
} else {
sqlList.remove(j);
}
public static String dealDate(String oldDateStr) throws ParseException {
DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
Date date = df.parse(oldDateStr);
SimpleDateFormat df1 = new SimpleDateFormat ("EEE MMM dd HH:mm:ss Z yyyy", Locale.UK);
Date date1 = df1.parse(date.toString());
DateFormat df2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
return df2.format(date1);
}
上次出现这个错误很奇怪,就是substring这个方法没有直接用在字符串上,而是一个list.map.get().subString然后就报错了,后来定义了一个中间变量就可以了,直接String.subString.
还有就是需要判断一下这个list是否为null和size()>0
emm这个很简单,但主要是一个思维,我之前是想看那个list里那个时间更早,然后就把这个更早的时间的这条记录保留,更晚的就不要,所以去除list,emm好像还是很简单,唉忘了之前纠结的是啥了。
testList.remove(j);//删除重复元素。
循环依赖报错,上次遇到这个是git代码的操作处理问题,后来重新拉一遍就好了 。
方法一:通过map.keySet()方法
Map<String, String> map1 = new HashMap<String, String>();
Map<String, String> map2 = new HashMap<String, String>();
for(String key1 : map1.keySet()){
String map1value = map1.get(key1);
String map2value = map2.get(key1);
if (!map1value.equals(map2value)) {
...
}
}
//
Iterator<String> iter1 = map1.keySet().iterator();
while(iter1.hasNext()){
String map1key=iter1.next();
String map1value = map1.get(map1key);
String map2value = map2.get(map1key);
if (!map1value.equals(map2value)) {
...
}
}
就是commit的时候第一次需要填写信息
解决方法: 在commit message中填写内容, 比如说: 这是我第一次提交
当添加了提交信息之后, 那么就可以正确提交了, 不知道是github为何强制设置了必须填写提交信息这样的设定.
String str = "abcdefg";
System.out.println("截取最后一个字符串生成的新字符串为: " + str.substring(0,str.length()-1));
//去点支字符串前后字符,比如冒号
public static String DealString(String ret) {
if(ret!=null) {
ret = replaceFirst(ret, "'", "");
ret = replaceLast(ret, "'", "");
}
return ret;
}
private static String replaceFirst(String ret, String strToReplace, String replaceWithThis) {
return ret.replaceFirst(strToReplace, replaceWithThis);
}
public static String replaceLast(String text, String strToReplace, String replaceWithThis) {
return text.replaceFirst("(?s)" + strToReplace + "(?!.*?" + strToReplace + ")", replaceWithThis);
}
截取?之前字符串
String str1=str.substring(0, str.indexOf("?"));
截取?之后字符串
String str1=str.substring(0, str.indexOf("?"));
String str2=str.substring(str1.length()+1, str.length());
取出正数第二个“.”后面的内容
String str ="232ljsfsf.sdfl23.ljsdfsdfsdfss.23423.sdfsdfsfd";
//获得第一个点的位置
int index=str.indexOf(".");
System.out.println(index);
//根据第一个点的位置 获得第二个点的位置
index=str.indexOf(".", index+1);
//根据第二个点的位置,截取 字符串。得到结果 result
String result=str.substring(index);
//输出结果
System.out.println(result);
截取最后一个\后面的所有字符
字符串.substring(字符串.lastIndexOf("\\")+1)
截取最后一个\后面的所有字符
columnEntity.getUrl().substring(0,columnEntity.getUrl().lastIndexOf("/"))
应该是不小心按了键盘上的insert键,再按下切换回来就可以
if(capital.startsWith("INSERT")) {
sqlList.add(sql);
}
StringUtils.startsWith("sssdf", "sssdf");//结果是:true
StringUtils.startsWith("sssdf", "f");//结果是:false
StringUtils.endsWith("aabcde", "d");
public class TraversalSet {
public static void main(String args[]){
List<String> list = new ArrayList<>(
Arrays.asList("tom","cat","Jane","jerry"));
Set<String> set = new HashSet<>();
set.addAll(list);
//方法1 集合类的通用遍历方式, 从很早的版本就有, 用迭代器迭代
Iterator it1 = set.iterator();
while(it1.hasNext()){
System.out.println(it1.next());
}
//方法2 集合类的通用遍历方式, 从很早的版本就有, 用迭代器迭代
for(Iterator it2 = set.iterator();it2.hasNext();){
System.out.println(it2.next());
}
//方法3 增强型for循环遍历
for(String value: set){
System.out.println(value);
}
}
}
//方法1
System.out.println(map.containsKey("5"));
//方法2
Iterator keys = map.keySet().iterator();
String key;
while(keys.hasNext()){
key = (String) keys.next();
if ("1".equals(key)) {
System.out.println("存在");
}
}
set中,元素是无序的,且不可重复;
需要删除List和Set中的某些元素,当时使用边遍历,边删除的方法,却报了以下异常:
ConcurrentModificationException
错误代码的写法,也就是报出上面异常的写法
Set<CheckWork> set = this.getUserDao().getAll(qf).get(0).getActionCheckWorks();
for(CheckWork checkWork : set){
if(checkWork.getState()==1){
set.remove(checkWork);
}
}
注意:使用上面的写法就会报上面的ConcurrenModificationException异常,原因是,集合不可以一边遍历一边删除。
正确的写法如下:
List<CheckWork> list = this.getUserDao().getAll();
Iterator<CheckWork> chk_it = list.iterator();
while(chk_it.hasNext()){
CheckWork checkWork = chk_it.next();
if(checkWork.getPlanState()==1){
chk_it.remove();
}
}
Set<CheckWork> set = this.getUserDao().getAll().get(0).getActionCheckWorks();
Iterator<CheckWork> it = set.iterator();
while(it.hasNext()){
CheckWork checkWork = it.next();
if(checkWork.getState()==1){
it.remove();
}
}
在集合中,我们再使用迭代返回元素时,是不能用集合的remove()方法删除元素的,只能使用迭代器中提供的remove()方法。
错误原因:
主键自增的表进行了同主键的重复插入,也就是常说的主键冲突。
解决方案:
1、根据个人具体场景,不重复插入数据即可
2、插入数据的时候,不设置主键的值
3、插入数据的时候使用insert ignore ,保证已有记录便不再插入
原因是:
xml文件中查询语句查出多条数据,但是返回的类型只能是一条。
解决办法:
String 转 Json
@Test
public void test(){
String str = "{\"age\":\"24\",\"name\":\"cool_summer_moon\"}";
JSONObject jsonObject = JSONObject.parseObject(str);
System.out.println("json对象是:" + jsonObject);
Object object = jsonObject.get("name");
System.out.println("name值是:"+object);
}
Json 转 String
@Test
public void test(){
String str = "{\"age\":\"24\",\"name\":\"cool_summer_moon\"}";
JSONObject jsonObject = JSONObject.parseObject(str);
//json对象转字符串
String jsonString = jsonObject.toJSONString();
System.out.println("json字符串是:" + jsonString);
}
String 转 Map
@Test
public void test(){
String str = "{\"age\":\"24\",\"name\":\"cool_summer_moon\"}";
JSONObject jsonObject = JSONObject.parseObject(str);
//json对象转Map
Map<String,Object> map = (Map<String,Object>)jsonObject;
System.out.println("map对象是:" + map);
Object object = map.get("age");
System.out.println("age的值是"+object);
}
Map 转 String
@Test
public void test(){
Map<String,Object> map = new HashMap<>();
map.put("age", 24);
map.put("name", "cool_summer_moon");
String jsonString = JSON.toJSONString(map);
System.out.println("json字符串是:"+jsonString);
}
BeanUtils位于org.apache.commons.beanutils.BeanUtils下面,其方法populate的作用解释如下:
完整方法:
BeanUtils.populate( Object bean, Map properties ),
这个方法会遍历map
BeanUtils.copyProperties
BeanUtils.copyProperties(“转换后的类”, “要转换的类”);
原理:
其原理是通过JDK自带的反射机制动态的去get,set,从而去转换我们的类。但是要注意一点他们所支持的数据类型,还有一个就是假如一个类里面又写了一个类,例如这种:
删除本地分支:git branch -d 分支名(remotes/origin/分支名)
强制删本地:git branch -D 分支名
删除远程分支:git push origin --delete 分支名(remotes/origin/分支名)
可以打开idea终端或者打开git 或者直接界面上操作
这个IDEA推送项目到啊服务器 提示 Push master to origin/master was rejected by remote,有可能是当前用户没有提交权限。
还有就是这个分支是保护分支,也就是master,这是不能随便push代码的,也可能是我们再命名分支的时候,不注意含有master这个单词,也会被检测为保护分支,因为它是模糊查询。
写java.util.String会报错,这是可以不写或者写map改变传来的参数或者用注解
得到最新的map后,先将其转化为数组,然后再转化为map
Map<String, CsfSrvServiceParam> csfParam = new HashMap();
Map<String, a> a = new HashMap();
Map<String, b> b = new HashMap();
Map<String, c> c = new HashMap();
//根据delete在做一个set
CSFBeanUtils.getCSFDeleteSet(deleteSql, deleteSet);
//找到最大的那个insertMap,循环完整,可能修改的时候insert不全。不好做就随便一个,后面再判断是否为空,再处理多的insert
Map<String, Object> maxMap = new HashMap<>();
String demo3 = "";
if (a.size() >= b.size() && a.size() >= c.size()) {
demo3 = JSON.toJSONString(csfParam);
} else if (b.size() >= a.size() && b.size() >= c.size()) {
demo3 = JSON.toJSONString(csfServiceInfo);
} else if (c.size() >= a.size() && c.size() >= b.size()) {
demo3 = JSON.toJSONString(registerByCodeInfo);
}
JSONObject jsonObject = JSONObject.parseObject(demo3);
maxMap = (Map<String, Object>) jsonObject;
Map<String, String> reqBodyMap = JSON.parseObject(requestBody, new TypeReference<Map<String, String>>(){});
Map<String, String> userMap = JSON.parseObject(reqBodyMap.get("user"), new TypeReference<Map<String, String>>(){});
//1获取mergeRequest的sql内容
Map<String, String> objectAttributes = JSON.parseObject(reqBodyMap.get("object_attributes"), new TypeReference<Map<String, String>>(){});
String projectId = objectAttributes.get("target_project_id");