Tombstone日志的生成
Android默认是不会抓取coredump文件的,AOSP在进程发生内存访问异常的时候一般会在 data/tombstones/ 下面生成“tombstone_0x”形式命名的文件,这个文件是debuggerd进程来抓取的,在可执行文件被加载的时候会执行到bionic/linker/debugger.cpp这个文件的debuggerd_init函数,在这个函数里面注册了信号处理函数为debuggerd_signal_handler,所以当这个进程接收到SIGABRT、SIGBUS、SIGSEGV等signal的时候kernel都会回调debuggerd_signal_handler这个函数来处理. __LIBC_HIDDEN__ void debuggerd_init ( ) { struct sigaction action ; memset ( & action , 0 , sizeof ( action ) ) ; sigemptyset ( & action . sa_mask ) ; action . sa_sigaction = debuggerd_signal_handler ; action . sa_flags = SA_RESTART | SA_SIGINFO ; // Use the alternate signal stack if available so we can catch stack overflows. action . sa_flags |= SA_ONSTACK ; sigaction ( SIGABRT , & action , nullptr ) ; sigaction ( SIGBUS , & action , nullptr ) ; sigaction ( SIGFPE , & action , nullptr ) ; sigaction ( SIGILL , & action , nullptr ) ; sigaction ( SIGSEGV , & action , nullptr ) ; # if defined(SIGSTKFLT) sigaction ( SIGSTKFLT , & action , nullptr ) ; # endif sigaction ( SIGTRAP , & action , nullptr ) ; }
debuggerd_signal_handler的实现如下,它的作用就是给守护进程发送一个socket请求,由后者通过ptrace调用来获取出错进程的出错地址,出错信号,线程堆栈、/proc/*/maps等信息,也就是上面所讲述的tombstone文件,zygote进程的app_process可执行文件在第一次被加载的时候也会执行上面的debuggerd_init逻辑,得益于Linux的fock调用,所有的zygote的子进程都有这个信号处理过程,不需要再另外添加代码. static void debuggerd_signal_handler ( int signal_number , siginfo_t * info , void * ) { // It's possible somebody cleared the SA_SIGINFO flag, which would mean // our "info" arg holds an undefined value. if ( ! have_siginfo ( signal_number ) ) { info = nullptr ; } log_signal_summary ( signal_number , info ) ; { send_debuggerd_packet ( info ) ; // We need to return from the signal handler so that debuggerd can dump the // thread that crashed, but returning here does not guarantee that the signal // will be thrown again, even for SIGSEGV and friends, since the signal could // have been sent manually. Resend the signal with rt_tgsigqueueinfo(2) to // preserve the SA_SIGINFO contents. signal ( signal_number , SIG_DFL ) ; struct siginfo si ; if ( ! info ) { memset ( & si , 0 , sizeof ( si ) ) ; si . si_code = SI_USER ; si . si_pid = getpid ( ) ; si . si_uid = getuid ( ) ; info = & si ; } else if ( info -> si_code >= 0 || info -> si_code == SI_TKILL ) { // rt_tgsigqueueinfo(2)'s documentation appears to be incorrect on kernels // that contain commit 66dd34a (3.9+). The manpage claims to only allow // negative si_code values that are not SI_TKILL, but 66dd34a changed the // check to allow all si_code values in calls coming from inside the house. } int rc = syscall ( SYS_rt_tgsigqueueinfo , getpid ( ) , gettid ( ) , signal_number , info ) ; if ( rc != 0 ) { __libc_format_log ( ANDROID_LOG_FATAL , "libc" , "failed to resend signal during crash: %s" , strerror ( errno ) ) ; _exit ( 0 ) ; } }
Tombstone日志 pid : 27730 , tid : 27736 , name : thermalloadalgo >> > / vendor / bin / thermalloadalgod << < signal 6 ( SIGABRT ) , code - - - - - - - - , fault addr - - - - - - - - r0 00000000 r1 00006c52 r2 00000006 r3 00000008 r4 f0ce558c r5 00000006 r6 f0ce5534 r7 0000010c r8 05f481e2 r9 f0bfca90 sl 00000000 fp ffea81cc ip 00000002 sp ffea7f70 lr f0896507 pc f0898d64 cpsr 20070010 backtrace : #00 pc 0004ad64 /system/lib/libc.so (tgkill+12) #01 pc 00048503 /system/lib/libc.so (pthread_kill+34) #02 pc 0001d4a5 /system/lib/libc.so (raise+10) #03 pc 00018fe1 /system/lib/libc.so (__libc_android_abort+34) #04 pc 00017044 /system/lib/libc.so (abort+4) #05 pc 0001b49f /system/lib/libc.so (__libc_fatal+22) #06 pc 0001b47f /system/lib/libc.so (__fortify_chk_fail+26) #07 pc 00050cbb /system/lib/libc.so (__sprintf_chk+66) #08 pc 000039fb /system/vendor/lib/libthermalalgo.so (_Z12get_uid_tputi+54) #09 pc 00003b3b /system/vendor/lib/libthermalalgo.so (_Z18update_avg_fg_tputv+14) #10 pc 00002df1 /system/vendor/lib/libthermalalgo.so (_Z3spav+324) #11 pc 000020ed /system/vendor/lib/libthermalalgo.so (libthermal_algo_setup+244) #12 pc 000008df /system/vendor/bin/thermalloadalgod #13 pc 00016c5d /system/lib/libc.so (__libc_init+48) #14 pc 00000770 /system/vendor/bin/thermalloadalgod stack : ffea7f30 f0bfd114 / system / vendor / lib / libthermalalgo . so ffea7f34 00000000 ffea7f38 ffea81cc [ stack ] ffea7f3c f0893dd3 / system / lib / libc . so ( vsnprintf + 138 ) ffea7f40 ffffffff ffea7f44 898045b6 ffea7f48 00000000 ffea7f4c 00000000 ffea7f50 00000000 ffea7f54 00000000 ffea7f58 00000000 ffea7f5c 00000000 ffea7f60 ffffffff ffea7f64 00004000 ffea7f68 f0ce558c ffea7f6c f08964f7 / system / lib / libc . so ( pthread_kill + 22 ) #00 ffea7f70 00000000 . . . . . . . . . . . . . . . . #01 ffea7f70 00000000 ffea7f74 00000006 ffea7f78 00000000 ffea7f7c f0bff168 / system / vendor / lib / libthermalalgo . so ffea7f80 f0bff160 / system / vendor / lib / libthermalalgo . so ffea7f84 f086b4a9 / system / lib / libc . so ( raise + 14 ) . . . . . .
debuggerd守护进程抓取的tombstone文件内容大概如上所示,这个Log具体说明了如下信息： 出错的进程名字为 /vendor/bin/thermalloadalgod ,它的pid是 27730 ,而具体导致接收到这次信号的tid也为 27736 . 进程收到的是SIGABRT信号. 抓取这个日志的时候,每个寄存器的内容,分析问题的时候一般需要结合反汇编代码和这里的寄存器内容分析. 这个线程的函数栈帧信息,也就是backtrace,从中我们可以看到这个线程的函数调用流程,因为tombstone文件一般是在终端抓取的,由于终端的可执行文件和so文件并没有保存有可供调试的符号信息,所以只能看到是哪个函数,但是对应不到对应的代码行,如果有对应的符号信息,可以用addr2line等工具把这里的地址信息对应的代码行,建议用add2line的时候 加上 “-ie”参数,可以把inline函数也打印出来. 这个线程对应的函数栈的内容,函数栈用来保存局部变量、返回地址、SP寄存器等内容.
常见信号 SIGABRT 在Android里面,这个信号一般是进程自己检测到不可恢复的错误之后,主动调用abort函数之后会接收到的一种信号,一般在log里面会打印出调用abort的原因,这种问题相对来说可能容易解决一些,只要根据错误提示信息,就可以去找相应的原因. SIGSEGV 在POSIX兼容的平台上, SIGSEGV 是当一个进程执行了一个无效的内存引用,或发生 段错误 时发送给它的信号,例如访问没有实际物理内存对应的虚拟地址,或者访问的时候出现权限异常,比较常见的就是空指针,对于SIGSEGV这一类信号,在tombstone log里面会给出fault addr,根据汇编代码和寄存器内容,可以接着往下分析. SIGBUS SIGBUS与SIGSEGV有点类似,也都是访问内存的时候出错,他们之间的区别可能在于如果那个地址是正常的（也就是说正常的虚拟地址,而且它也有对应的物理内存）,如果访问出错,那么就会上报SIGBUS,否则就上报的是SIGSEGV,例如有些芯片总线访问需要地址是4字节对齐的,如果那个地址不是对齐的,那么就会上报SIGBUS.
这三种信号在Android稳定性问题分析当中是比较常见的,除了这三种信号之外,其实Linux有64种信号,一般来说前面的32种是标准信号,后面32种是新增加的实时信号,对于标准信号,一个进程里面同一时间只能存在一个,而实时信号却没有这个限制,可以存在多个,这里借用 Unix系统中常用的信号含义 这个文章的内容对标准信号做一些简单的介绍 Signal Description
1 - SIGHUP 本信号在用户终端连接(正常或非正常)结束时发出, 通常是在终端的控制进程结束时, 通知同一session内的各个作业, 这时它们与控制终端不再关联。登录Linux时,系统会分配给登录用户一个终端(Session)。在这个终端运行的所有程序,包括前台进程组和后台进程组,一般都属于这个Session。当用户退出Linux登录时,前台进程组和后台有对终端输出的进程将会收到SIGHUP信号。这个信号的默认操作为终止进程,因此前台进程组和后台有终端输出的进程就会中止。不过可以捕获这个信号,比如wget能捕获SIGHUP信号,并忽略它,这样就算退出了Linux登录,wget也能继续下载。此外,对于与终端脱离关系的守护进程,这个信号用于通知它重新读取配置文件。 2 - SIGINT 程序终止(interrupt)信号, 在用户键入INTR字符(通常是Ctrl-C)时发出,用于通知前台进程组终止进程。 3 - SIGQUIT 和SIGINT类似, 但由QUIT字符(通常是Ctrl-)来控制. 进程在因收到SIGQUIT退出时会产生core文件, 在这个意义上类似于一个程序错误信号。 4 - SIGILL 执行了非法指令. 通常是因为可执行文件本身出现错误, 或者试图执行数据段. 堆栈溢出时也有可能产生这个信号。 5 - SIGTRAP 由断点指令或其它trap指令产生. 由debugger使用。 6 - SIGABRT 调用abort函数生成的信号。 7 - SIGBUS 非法地址, 包括内存地址对齐(alignment)出错。比如访问一个四个字长的整数, 但其地址不是4的倍数。它与SIGSEGV的区别在于后者是由于对合法存储地址的非法访问触发的(如访问不属于自己存储空间或只读存储空间)。 8 - SIGFPE 在发生致命的算术运算错误时发出. 不仅包括浮点运算错误, 还包括溢出及除数为0等其它所有的算术的错误。 9 - SIGKILL 用来立即结束程序的运行.本信号不能被阻塞、处理和忽略。如果管理员发现某个进程终止不了,可尝试发送这个信号。 10 - SIGUSR1 留给用户使用 11 - SIGSEGV 试图访问未分配给自己的内存, 或试图往没有写权限的内存地址写数据. 12 - SIGUSR2 留给用户使用 13 - SIGPIPE 管道破裂。这个信号通常在进程间通信产生,比如采用FIFO(管道)通信的两个进程,读管道没打开或者意外终止就往管道写,写进程会收到SIGPIPE信号。此外用Socket通信的两个进程,写进程在写Socket的时候,读进程已经终止。 14 - SIGALRM 时钟定时信号, 计算的是实际的时间或时钟时间. alarm函数使用该信号. 15 - SIGTERM 程序结束(terminate)信号, 与SIGKILL不同的是该信号可以被阻塞和处理。通常用来要求程序自己正常退出,shell命令kill缺省产生这个信号。如果进程终止不了,我们才会尝试SIGKILL。 17 - SIGCHLD 子进程结束时, 父进程会收到这个信号。如果父进程没有处理这个信号,也没有等待(wait)子进程,子进程虽然终止,但是还会在内核进程表中占有表项,这时的子进程称为僵尸进程。这种情况我们应该避免(父进程或者忽略SIGCHILD信号,或者捕捉它,或者wait它派生的子进程,或者父进程先终止,这时子进程的终止自动由init进程来接管)。 18- SIGCONT 让一个停止(stopped)的进程继续执行. 本信号不能被阻塞. 可以用一个handler来让程序在由stopped状态变为继续执行时完成特定的工作. 例如, 重新显示提示符 19 - SIGSTOP 停止(stopped)进程的执行. 注意它和terminate以及interrupt的区别:该进程还未结束, 只是暂停执行. 本信号不能被阻塞, 处理或忽略. 20 - SIGTSTP 停止进程的运行, 但该信号可以被处理和忽略. 用户键入SUSP字符时(通常是Ctrl-Z)发出这个信号 21 - SIGTTIN 当后台作业要从用户终端读数据时, 该作业中的所有进程会收到SIGTTIN信号. 缺省时这些进程会停止执行. 22 - SIGTTOU 类似于SIGTTIN, 但在写终端(或修改终端模式)时收到. 23 - SIGURG 有"紧急"数据或out-of-band数据到达socket时产生. 24 - SIGXCPU 超过CPU时间资源限制. 这个限制可以由getrlimit/setrlimit来读取/改变。 25 - SIGXFSZ 当进程企图扩大文件以至于超过文件大小资源限制。 26 - SIGVTALRM 虚拟时钟信号. 类似于SIGALRM, 但是计算的是该进程占用的CPU时间. 27 - SIGPROF 类似于SIGALRM/SIGVTALRM, 但包括该进程用的CPU时间以及系统调用的时间. 28 - SIGWINCH 窗口大小改变时发出. 29 - SIGIO 文件描述符准备就绪, 可以开始进行输入/输出操作. 31 - SIGSYS 非法的系统调用
objdump工具 现在距离 Python 3.9.0 的最终版本还有 3 个月,官方公布的时间线是：
cp命令取消提示的方法 Linux默认cp命令带参数-i如果有重复的文件会提示覆盖
假如,明天你财务自由了,你会想去做些什么？
文章内容输出来源：拉勾教育Java高薪训练营
双向绑定,也就是说js中的数据传到页面,页面中的内容到js,实现同步更新,简单的演示可以直接复制下放HTML代码运行。
Document Document 求：
先用react试了下, 搞了几个小时都没做出来想要的样子, 用vue3半个小时弄好了
react很多时候你觉得这么做没问题, 但是当你写了代码就会出问题, vue很多时候很符合直觉, 就算出错了, 也能根据经验和直觉快速定位
也可能是react用的太少, 毕竟也就不到一个月....
Java内存模型(Java Memory Model,JMM)是java虚拟机规范定义的,用来屏蔽掉java程序在各种不同的硬件和操作系统对内存的访问的差异,这样就可以实现java程序在各种不同的平台上都能达到内存访问的一致性。可以避免像c++等直接使用物理硬件和操作系统的内存模型在不同操作系统和硬件平台下表现不同,比如有些c/c++程序可能在windows平台运行正常,而在linux平台却运行有问题。
作者：leapMie 的博客 https://blog.leapmie.com/archives/418/
对于学习前端开发有前途吗？行情怎么样,好就业吗?这样的问题相信都看了很多很多,每个人的回答都有些差别。但是唯一的一点肯定的,学习前端的前景是很不错的。
Mybatis学习（一）：基础概念和简单自定义持久层框架demo 一、一个简单自定义持久层框架demo 1.1 普通的JDBC连接数据库 1.2 对jdbc存在的问题分析和解决 1.3 简单设计一个持久层框架 1.4 简单测试
一、一个简单自定义持久层框架demo
1.1 普通的JDBC连接数据库 public class Test { public static void main(String[] args) { Connection connection = null; PreparedStatement preparedStatement = null; ResultSet resultSet = null; try { //加载数据库驱动 Class.forName("com.mysql.jdbc.Driver"); //通过驱动管理类获取连接 connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatis", "root", "root"); //定义SQL语句,其中？表示占位符 String sql = "select * from user where name = ?"; preparedStatement = connection.prepareStatement(sql); //设置参数,参数是从1开始 preparedStatement.setString(1, "zhangsan"); //执行SQL查询数据库返回查询结果集 resultSet = preparedStatement.executeQuery(); //遍历查询结果集 while (resultSet.next()) { int id = resultSet.getInt("id"); String name = resultSet.getString("name"); User user = new User(); user.setId(id); user.setName(name); System.out.println(user); } } catch (Exception e) { e.printStackTrace(); } finally { if (resultSet != null) { try { resultSet.close(); } catch (SQLException sqlException) { sqlException.printStackTrace(); } } try { if (preparedStatement != null) { preparedStatement.close(); } } catch (SQLException sqlException) { sqlException.printStackTrace(); } try { if (connection != null) { connection.close(); } } catch (SQLException sqlException) { sqlException.printStackTrace(); } } } }
1.2 对jdbc存在的问题分析和解决
从上边1.1的手写JDBC连接可以看出： 频繁创建和释放数据库连接,性能损失； SQL语句是写死的,在实际项目中是会经常变化的； preparedStatement传入参数时也有硬编码的存在,不易维护； 从resultSet获取结果信息封装为Java某个对象时也存在硬编码问题；
我们可以用以下方法解决上述问题： 采用连接池的方式避免频繁创建、释放数据库连接； 对硬编码的问题我们可以用配置文件的方式去替代； 用反射及内省方法完成resultSet结果集到Java对象的封装；
1.3 简单设计一个持久层框架
用户端：引入自定义框架的jar包。
（1）提供一个Mapper.xml存储关于SQL的配置信息文件；
select * from user namespace.id来组成statementId唯一标识SQL语句
（2）提供一个MapperConfig.xml存储关于数据源等配置信息文件,引入Mapper.xml；
框架端：
新建一个maven项目,引入相关依赖。
4.0.0 com.customize customizeOrm 1.0-SNAPSHOT UTF-8 UTF-8 1.8 1.8 1.8 mysql mysql-connector-java 8.0.20 c3p0 c3p0 0.9.1.2 log4j log4j 1.2.17 dom4j dom4j 1.6.1 jaxen jaxen 1.1.6 junit junit 4.12 test org.apache.maven.plugins maven-compiler-plugin 8 8 加载配置文件
配置文件以流的形式被读取出来,放在内存中不好操作,我们创建bean对象的方式来存储。
(1) 创建Resources类,根据配置文件的路径,加载配置文件成字节输入流存在内存中。 import java.io.InputStream; public class Resources { public static InputStream getResourcesAsStream(String path){ return Resources.class.getResourceAsStream(path); } }
(2) 创建Configuration对象存MapperConfig.xml解析到的内容； package com.customer.config; import javax.sql.DataSource; import java.util.HashMap; import java.util.Map; public class Configuration { /** * 数据源信息 */ private DataSource dataSource; /** * mapper的相关信息 */ private Map
map = new HashMap<>(); public DataSource getDataSource() { return dataSource; } public void setDataSource(DataSource dataSource) { this.dataSource = dataSource; } public Map getMap() { return map; } public void setMap(Map map) { this.map = map; } } 标签 Element rootElement = document.getRootElement(); Properties properties = new Properties(); List propertyNodes = rootElement.selectNodes("//property"); for (Element propertyNode : propertyNodes) { String name = propertyNode.attributeValue("name"); String value = propertyNode.attributeValue("value"); properties.setProperty(name,value); } //连接池 ComboPooledDataSource dataSource = new ComboPooledDataSource(); dataSource.setDriverClass(properties.getProperty("driverClass")); dataSource.setJdbcUrl(properties.getProperty("jdbcUrl")); dataSource.setUser(properties.getProperty("user")); dataSource.setPassword(properties.getProperty("password")); //将连接池放入configuration对象中 configuration.setDataSource(dataSource); //利用XMLMapperBuilder解析mapper List mapperNodes = rootElement.selectNodes("//mapper"); XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(configuration); for (Element mapperElement : mapperNodes) { String path = mapperElement.attributeValue("resource"); xmlMapperBuilder.parseMapper(Resources.getResourcesAsStream(path)); } return configuration; } } 创建XMLMapperBuilder类解析mapper.xml文件,将解析到的信息封装到MappedStatement对象并注入Configuration中； 在这里插入代码片 创建SqlSessionFactory接口类及默认实现DefaultSqlSessionFactory,生产SqlSession对象。 package com.customer.io; import com.customer.config.Configuration; import com.customer.config.MappedStatement; import org.dom4j.Document; import org.dom4j.DocumentException; import org.dom4j.Element; import org.dom4j.io.SAXReader; import java.io.InputStream; import java.util.List; public class XMLMapperBuilder { private Configuration configuration; public XMLMapperBuilder(Configuration configuration) { this.configuration = configuration; } public Configuration parseMapper(InputStream inputStream) throws DocumentException, ClassNotFoundException { Document document = new SAXReader().read(inputStream); Element rootElement = document.getRootElement(); String namespace = rootElement.attributeValue("namespace"); List selectElements = rootElement.selectNodes("select"); for (Element selectElement : selectElements) { String id = selectElement.attributeValue("id"); //入参类型 String paramterType = selectElement.attributeValue("paramterType"); //返回类型 String resultType = selectElement.attributeValue("resultType"); //sql语句 String sql = selectElement.getTextTrim(); //唯一标识 namespace+id String key = namespace + id; //将解析到的SQL信息封装到MappedStatement对象中 MappedStatement mappedStatement = new MappedStatement(); mappedStatement.setId(id); mappedStatement.setSql(sql); mappedStatement.setParamterType(getClassTypeByStr(paramterType)); mappedStatement.setResultType(getClassTypeByStr(resultType)); //将封装好的MappedStatement对象注入Configuration对象中 configuration.getMap().put(key,mappedStatement); } return configuration; } private Class getClassTypeByStr(String typeStr) throws ClassNotFoundException { return Class.forName(typeStr); } } 创建SqlSessionFactoryBuilder类生成SqlSessionFactory package com.customer.sqlsession; import com.customer.config.Configuration; import com.customer.io.XMLConfigerBuilder; import org.dom4j.DocumentException; import javax.naming.NamingException; import java.beans.PropertyVetoException; import java.io.InputStream; public class SqlSessionFactoryBuilder { private Configuration configuration; public SqlSessionFactoryBuilder() { configuration = new Configuration(); } public SqlSessionFactory build(InputStream inputStream) throws ClassNotFoundException, PropertyVetoException, DocumentException, NamingException { //1.解析配置文件得到Configuration对象 XMLConfigerBuilder xmlConfigerBuilder = new XMLConfigerBuilder(configuration); xmlConfigerBuilder.parseConfiguration(inputStream); //2.创建SqlSessionFactory return new DefaultSqlSessionFactory(configuration); } } 创建SqlSessionFactory接口和其默认实现类DefaultSqlSessionFactory,主要负责生产SqlSession package com.customer.sqlsession; public interface SqlSessionFactory { public SqlSession openSession(); } package com.customer.sqlsession; import com.customer.config.Configuration; public class DefaultSqlSessionFactory implements SqlSessionFactory{ private Configuration configuration; public DefaultSqlSessionFactory(Configuration configuration) { this.configuration = configuration; } @Override public SqlSession openSession() { return new DefaultSqlSession(configuration); } } 创建SqlSession接口及其默认实现类DefaultSqlSession,定义对数据库的操作：查询、新增、修改、删除 创建SqlSession接口,定义对数据库的操作：查询、新增、修改、删除 package com.customer.sqlsession; import java.util.List; public interface SqlSession { List selectList(String statementId, Object... param); T selectOne(String statementId, Object... param); } 创建SqlSession接口的默认实现类DefaultSqlSession package com.customer.sqlsession; import com.customer.config.Configuration; import com.customer.config.MappedStatement; import com.customer.executor.Executor; import com.customer.executor.SimpleExecutor; import java.util.List; public class DefaultSqlSession implements SqlSession { private Configuration configuration; public DefaultSqlSession(Configuration configuration) { this.configuration = configuration; } private Executor simpleExecutor = new SimpleExecutor(); @Override public List selectList(String statementId, Object... param) { MappedStatement mappedStatement = configuration.getMap().get(statementId); return simpleExecutor.query(configuration, mappedStatement, param); } @Override public T selectOne(String statementId, Object... param) { List objects = selectList(statementId, param); if (objects.size() > 1) { throw new RuntimeException("Too many returns !"); } return (T) objects.get(0); } } 创建Executor接口及其实现类SimpleExecutor,定义query()方法执行jdbc。 创建Executor接口,定义query()方法 package com.customer.executor; import com.customer.config.Configuration; import com.customer.config.MappedStatement; import java.util.List; public interface Executor { List query(Configuration configuration, MappedStatement mappedStatement, Object[] param); } 创建Executor接口的实现类SimpleExecutor package com.customer.executor; import com.customer.config.Configuration; import com.customer.config.MappedStatement; import com.customer.util.GenericTokenParser; import com.customer.util.ParameterMapping; import com.customer.util.ParameterMappingTokenHandler; import java.beans.IntrospectionException; import java.beans.PropertyDescriptor; import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.ResultSetMetaData; import java.sql.SQLException; import java.util.ArrayList; import java.util.List; public class SimpleExecutor implements Executor { private Connection connection = null; @Override public List query(Configuration configuration, MappedStatement mappedStatement, Object[] param) throws SQLException, NoSuchFieldException, IllegalAccessException, InstantiationException, IntrospectionException, InvocationTargetException { //1.获取数据库连接 connection = configuration.getDataSource().getConnection(); //2.获取要执行的SQL语句 String sql = mappedStatement.getSql(); //3.对sql进行预编译处理 BoundSql boundSql = getBoundSql(sql); //4.获取预编译对象PreparedStatement PreparedStatement preparedStatement = connection.prepareStatement(boundSql.getParseSql()); //5.设置参数对 Class paramterType = mappedStatement.getParamterType(); List parameterMappingList = boundSql.getParameterMappingList(); for (int i = 0; i < parameterMappingList.size(); i++) { ParameterMapping parameterMapping = parameterMappingList.get(i); String content = parameterMapping.getContent(); //利用反射 Field declaredField = paramterType.getDeclaredField(content); declaredField.setAccessible(true); Object o = declaredField.get(param[0]); preparedStatement.setObject(i + 1, o); } //6.执行sql语句 ResultSet resultSet = preparedStatement.executeQuery(); //7.封装返回结果集 Class resultType = mappedStatement.getResultType(); ArrayList list = new ArrayList(); while (resultSet.next()) { Object o = resultType.newInstance(); ResultSetMetaData metaData = resultSet.getMetaData(); for (int i = 0; i < metaData.getColumnCount(); i++) { //字段名 String columnName = metaData.getColumnName(i); Object object = resultSet.getObject(columnName); PropertyDescriptor propertyDescriptor = new PropertyDescriptor(columnName, resultType); Method writeMethod = propertyDescriptor.getWriteMethod(); writeMethod.invoke(o, object); } list.add(o); } return (List) list; } private BoundSql getBoundSql(String sql) { //标记处理类：配置标记解析器来完成对占位符的解析处理工作 ParameterMappingTokenHandler parameterMappingTokenHandler = new ParameterMappingTokenHandler(); GenericTokenParser genericTokenParser = new GenericTokenParser("#{", "}", parameterMappingTokenHandler); //解析得到的sql String parse = genericTokenParser.parse(sql); //#{}里面解析出来的参数名称 List parameterMappings = parameterMappingTokenHandler.getParameterMappings(); return new BoundSql(parse, parameterMappings); } } 引入预编译处理工具类 package com.customer.util; public class ParameterMapping { private String content; public ParameterMapping(String content) { this.content = content; } public String getContent() { return content; } public void setContent(String content) { this.content = content; } } package com.customer.util; /** * @author Clinton Begin */ public interface TokenHandler { String handleToken(String content); } package com.customer.util; import java.util.ArrayList; import java.util.List; public class ParameterMappingTokenHandler implements TokenHandler { private List parameterMappings = new ArrayList(); // context是参数名称 #{id} #{username} @Override public String handleToken(String content) { parameterMappings.add(buildParameterMapping(content)); return "?"; } private ParameterMapping buildParameterMapping(String content) { ParameterMapping parameterMapping = new ParameterMapping(content); return parameterMapping; } public List getParameterMappings() { return parameterMappings; } public void setParameterMappings(List parameterMappings) { this.parameterMappings = parameterMappings; } } /** * Copyright 2009-2017 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.customer.util; /** * @author Clinton Begin */ public class GenericTokenParser { private final String openToken; //开始标记 private final String closeToken; //结束标记 private final TokenHandler handler; //标记处理器 public GenericTokenParser(String openToken, String closeToken, TokenHandler handler) { this.openToken = openToken; this.closeToken = closeToken; this.handler = handler; } /** * 解析${}和#{} * @param text * @return * 该方法主要实现了配置文件、脚本等片段中占位符的解析、处理工作,并返回最终需要的数据。 * 其中,解析工作由该方法完成,处理工作是由处理器handler的handleToken()方法来实现 */ public String parse(String text) { // 验证参数问题,如果是null,就返回空字符串。 if (text == null || text.isEmpty()) { return ""; } // 下面继续验证是否包含开始标签,如果不包含,默认不是占位符,直接原样返回即可,否则继续执行。 int start = text.indexOf(openToken, 0); if (start == -1) { return text; } // 把text转成字符数组src,并且定义默认偏移量offset=0、存储最终需要返回字符串的变量builder, // text变量中占位符对应的变量名expression。判断start是否大于-1(即text中是否存在openToken),如果存在就执行下面代码 char[] src = text.toCharArray(); int offset = 0; final StringBuilder builder = new StringBuilder(); StringBuilder expression = null; while (start > -1) { // 判断如果开始标记前如果有转义字符,就不作为openToken进行处理,否则继续处理 if (start > 0 && src[start - 1] == '\\') { builder.append(src, offset, start - offset - 1).append(openToken); offset = start + openToken.length(); } else { //重置expression变量,避免空指针或者老数据干扰。 if (expression == null) { expression = new StringBuilder(); } else { expression.setLength(0); } builder.append(src, offset, start - offset); offset = start + openToken.length(); int end = text.indexOf(closeToken, offset); while (end > -1) {////存在结束标记时 if (end > offset && src[end - 1] == '\\') {//如果结束标记前面有转义字符时 // this close token is escaped. remove the backslash and continue. expression.append(src, offset, end - offset - 1).append(closeToken); offset = end + closeToken.length(); end = text.indexOf(closeToken, offset); } else {//不存在转义字符,即需要作为参数进行处理 expression.append(src, offset, end - offset); offset = end + closeToken.length(); break; } } if (end == -1) { // close token was not found. builder.append(src, start, src.length - start); offset = src.length; } else { //首先根据参数的key（即expression）进行参数处理,返回?作为占位符 builder.append(handler.handleToken(expression.toString())); offset = end + closeToken.length(); } } start = text.indexOf(openToken, offset); } if (offset < src.length) { builder.append(src, offset, src.length - offset); } return builder.toString(); } } 创建BoundSql类存储处理后的sql和参数对 package com.customer.executor; import com.customer.util.ParameterMapping; import java.util.List; public class BoundSql { private String parseSql; private List parameterMappingList; public BoundSql(String parseSql, List parameterMappingList) { this.parseSql = parseSql; this.parameterMappingList = parameterMappingList; } public String getParseSql() { return parseSql; } public void setParseSql(String parseSql) { this.parseSql = parseSql; } public List getParameterMappingList() { return parameterMappingList; } public void setParameterMappingList(List parameterMappingList) { this.parameterMappingList = parameterMappingList; } } userList = sqlSession.selectList("user.selectList"); for (User user : userList) { System.out.println(user); } } } [TOC] virtualbox-2.2
[TOC]
NTPv1 1988年6月 RFC 1059 首次提出了完整的NTP规则以及算法,但是NTPv1不支持认证和控制消息 NTPv3 NTPv4 1992年3月 2010年6月 RFC 1305 RFC 5905 正式引入了校正原则,并改进了时钟选择和时钟过滤算法。NTPv3目前应用较为广泛,仅支持IPv4 支持IPv4和IPv6,安全性更高。 两栈共享空间
[toc]
2 3 192.168.8.131 192.168.8.1 CentOS 7.6.1810 windows 10 mysql PyCharm Pro mysql数据 专业版能够使用与centos远程同步配置 hello django
') 线性表的链式存储结构 3. 若到链表末尾p为空,则说明第i个元素不存在； data； 单链表的插入标准语句s->next=p->next; p->next = s; 返回成功。 next赋值给q； 单链表的删除标准语句p->next = q->next; 将q结点中的数据赋值给e,作为返回； 释放q节点； 返回成功。
栈(stack)是 限定仅在表尾插入和删除操作的线性表。
Lambda表达式
一、Lambda表达式简介
什么是Lambda？
Lambda是JAVA 8添加的新特性,说白了,Lambda是一个匿名函数
为什么使用Lambda
使用Lambda表达式可以对一个接口的方法进行非常简洁的实现
Lambda对接口的要求
虽然可以使用Lambda表达式对某些接口进行简单的实现,但是并不是所有的接口都可以用Lambda表达式来实现,要求接口中定义的 必须要实现的抽象方法只能是一个 在JAVA8中 ,对接口加了一个新特性：default 可以使用default对接口方法进行修饰,被修饰的方法在接口中可以默认实现
@FunctionalInterface
修饰函数式接口的,接口中的抽象方法只有一个
二、Lambda的基础语法
1.语法 // 1.Lambda表达式的基础语法 // Lambda是一个匿名函数 一般关注的是以下两个重点 // 参数列表 方法体 /** * （）：用来描述参数列表 * {}：用来描述方法体 有时可以省略 * ->: Lambda运算符 读作goes to * 例 Test t=()->{System.out.println("hello word")}; 大括号可省略 */
2.创建多个接口 /** * 无参数无返回值接口 * @author Alan * @version 1.0 * @date 2020-05-27 10:24 */ @FunctionalInterface public interface LambdaNoneReturnNoneParmeter { void test(); } /** * 无返回值有单个参数 * @author Alan * @version 1.0 * @date 2020-05-27 10:26 */ @FunctionalInterface public interface LambdaNoneReturnSingleParmeter { void test(int n); } /** * 无返回值 多个参数的接口 * @author Alan * @version 1.0 * @date 2020-05-27 10:27 */ @FunctionalInterface public interface LambdaNoneReturnMutipleParmeter { void test(int a,int b); } /** * 有返回值 无参数接口 * @author Alan * @version 1.0 * @date 2020-05-27 10:28 */ @FunctionalInterface public interface LambdaSingleReturnNoneParmeter { int test(); } /** * 有返回值 有单个参数的接口 * @author Alan * @version 1.0 * @date 2020-05-27 10:29 */ @FunctionalInterface public interface LambdaSingleReturnSingleParmeter { int test(int n); } /** * 有返回值 有多个参数的接口 * @author Alan * @version 1.0 * @date 2020-05-27 10:30 */ @FunctionalInterface public interface LambdaSingleReturnMutipleParmeter { int test(int a,int b); }
3.创建测试类 package com.alan.learn.syntax; import com.alan.learn.interfaces.*; /** * @author Alan * @version 1.0 * @date 2020-05-27 10:33 */ public class Syntax1 { public static void main(String[] args) { // 1.Lambda表达式的基础语法 // Lambda是一个匿名函数 一般关注的是以下两个重点 // 参数列表 方法体 /** * （）：用来描述参数列表 * {}：用来描述方法体 * ->: Lambda运算符 读作goes to */ // 无参无返回 LambdaNoneReturnNoneParmeter lambda1=()->{ System.out.println("hello word"); }; lambda1.test(); // 无返回值 单个参数 LambdaNoneReturnSingleParmeter lambda2=(int n)->{ System.out.println("参数是："+n); }; lambda2.test(10); // 无返回值 多个参数 LambdaNoneReturnMutipleParmeter lambda3=(int a,int b)->{ System.out.println("参数和是："+(a+b)); }; lambda3.test(10,12); // 有返回值 无参数 LambdaSingleReturnNoneParmeter lambda4=()->{ System.out.println("lambda4："); return 100; }; int ret=lambda4.test(); System.out.println("返回值是："+ret); // 有返回值 单个参数 LambdaSingleReturnSingleParmeter lambda5=(int a)->{ return a*2; }; int ret2= lambda5.test(3); System.out.println("单个参数,lambda5返回值是:"+ret2); //有返回值 多个参数 LambdaSingleReturnMutipleParmeter lambda6=(int a,int b)->{ return a+b; }; int ret3=lambda6.test(12,14); System.out.println("多个参数,lambda6返回值是："+ret3); } } 输出结果： hello word 参数是：10 参数和是：22 lambda4： 返回值是：100 单个参数,lambda5返回值是:6 多个参数,lambda6返回值是：26
三、语法精简
针对上述基础语法的精简
1.参数类型精简 /** * 语法精简 * 1.参数类型 * 由于在接口的抽象方法中,已经定义了参数的数量类型 所以在Lambda表达式中参数的类型可以省略 * 备注：如果需要省略类型,则每一个参数的类型都要省略,千万不要一个省略一个不省略 */ LambdaNoneReturnMutipleParmeter lambda1=(int a,int b)-> { System.out.println("hello world"); }; 可以精简为: LambdaNoneReturnMutipleParmeter lambda1=(a,b)-> { System.out.println("hello world"); };
2.参数小括号精简 /** * 2.参数小括号 * 如果参数列表中,参数的数量只有一个 此时小括号可以省略 */ LambdaNoneReturnSingleParmeter lambda2=(a)->{ System.out.println("hello world"); }; 可以精简为: LambdaNoneReturnSingleParmeter lambda2= a->{ System.out.println("hello world"); };
3.方法大括号精简 /** * 3.方法大括号 * 如果方法体中只有一条语句,此时大括号可以省略 */ LambdaNoneReturnSingleParmeter lambda3=a->{ System.out.println("hello world"); }; 可以精简为: LambdaNoneReturnSingleParmeter lambda3=a->System.out.println("hello world");
4.大括号精简补充 /** * 4.如果方法体中唯一的一条语句是一个返回语句 * 贼省略大括号的同时 也必须省略return */ LambdaSingleReturnNoneParmeter lambda4=()->{ return 10; }; 可以精简为: LambdaSingleReturnNoneParmeter lambda4=()->10;
5.多参数,有返回值 精简 LambdaSingleReturnNoneParmeter lambda4=(a,b)->{ return a+b; }; 可以精简为: LambdaSingleReturnMutipleParmeter lambda5=(a,b)->a+b;
四、Lambda语法进阶
1.方法引用(普通方法与静态方法)
在实际应用过程中,一个接口在很多地方都会调用同一个实现,例如： LambdaSingleReturnMutipleParmeter lambda1=(a,b)->a+b; LambdaSingleReturnMutipleParmeter lambda2=(a,b)->a+b;
这样一来每次都要写上具体的实现方法 a+b,如果需求变更,则每一处实现都需要更改,基于这种情况,可以将后续的是实现更改为已定义的 方法,需要时直接调用就行
语法： /** *方法引用： * 可以快速的将一个Lambda表达式的实现指向一个已经实现的方法 * 方法的隶属者 如果是静态方法 隶属的就是一个类 其他的话就是隶属对象 * 语法：方法的隶属者::方法名 * 注意： * 1.引用的方法中,参数数量和类型一定要和接口中定义的方法一致 * 2.返回值的类型也一定要和接口中的方法一致 */
例： package com.alan.learn.syntax; import com.alan.learn.interfaces.LambdaSingleReturnSingleParmeter; /** * @author Alan * @version 1.0 * @date 2020-05-27 11:48 */ public class Syntax3 { public static void main(String[] args) { LambdaSingleReturnSingleParmeter lambda1=a->a*2; LambdaSingleReturnSingleParmeter lambda2=a->a*2; LambdaSingleReturnSingleParmeter lambda3=a->a*2; //简化 LambdaSingleReturnSingleParmeter lambda4=a->change(a); //方法引用 LambdaSingleReturnSingleParmeter lambda5=Syntax3::change; } /** * 自定义的实现方法 */ private static int change(int a){ return a*2; } }
2.方法引用(构造方法)
目前有一个实体类 public class Person { public String name; public int age; public Person() { System.out.println("Person的无参构造方法执行"); } public Person(String name, int age) { this.name = name; this.age = age; System.out.println("Person的有参构造方法执行"); } }
需求
两个接口,各有一个方法,一个接口的方法需要引用Person的无参构造,一个接口的方法需要引用Person的有参构造 用于返回两个Person对象,例： interface PersonCreater{ //通过Person的无参构造实现 Person getPerson(); } interface PersonCreater2{ //通过Person的有参构造实现 Person getPerson(String name,int age); }
那么可以写作： public class Syntax4 { public static void main(String[] args) { PersonCreater creater=()->new Person(); //引用的是Person的无参构造 //PersonCreater接口的方法指向的是Person的方法 PersonCreater creater1=Person::new; //等价于上面的()->new Person() //实际调用的是Person的无参构造 相当于把接口里的getPerson()重写成new Person()。 Person a=creater1.getPerson(); //引用的是Person的有参构造 PersonCreater2 creater2=Person::new; Person b=creater2.getPerson("张三",18); } }
注意：是引用无参构造还是引用有参构造 在于接口定义的方法参数
五、综合练习
1.集合排序案例 package com.alan.exercise; import com.alan.learn.data.Person; import java.util.ArrayList; /** * 集合排序案例 * @author Alan * @version 1.0 * @date 2020-05-27 15:08 */ public class Exercise1 { public static void main(String[] args) { //需求：已知在一个ArrayList中有若干各Person对象,将这些Person对象按照年龄进行降序排列 ArrayList
list=new ArrayList<>(); list.add(new Person("张三",10)); list.add(new Person("李四",12)); list.add(new Person("王五",13)); list.add(new Person("赵六",14)); list.add(new Person("李雷",11)); list.add(new Person("韩梅梅",8)); list.add(new Person("jack",10)); System.out.println("排序前："+list); //将排列的依据传入 具体的方法指向的是 内部元素的age相减 sort会依据结果的正负进行降序排列 //sort 使用提供的 Comparator对此列表进行排序以比较元素。 list.sort((o1, o2) -> o2.age-o1.age); System.out.println("排序后："+list); } } set=new TreeSet<>((o1, o2) -> o2.age-o1.age); * 这个获取的对象打印会少一个Person * 此时我们将方法修改 */ TreeSet set=new TreeSet<>((o1, o2) ->{ if(o1.age>=o2.age){ return -1; }else { return 1; } }); set.add(new Person("张三",10)); set.add(new Person("李四",12)); set.add(new Person("王五",13)); set.add(new Person("赵六",14)); set.add(new Person("李雷",11)); set.add(new Person("韩梅梅",8)); set.add(new Person("jack",10)); System.out.println(set); } } list=new ArrayList<>(); Collections.addAll(list,1,2,3,4,5,6,7,8,9); /** * list.forEach(Consumer action) * api文档解释： 对 集合中的每个元素执行给定的操作,直到所有元素都被处理或动作引发异常。 * 将集合中的每一个元素都带入到接口Consumer的方法accept中 然后方法accept指向我们的引用 * 输出集合中的所有元素 * list.forEach(System.out::println); */ //输出集合中所有的偶数 list.forEach(ele->{ if(ele%2==0){ System.out.println(ele); } }); } } list=new ArrayList<>(); list.add(new Person("张三",10)); list.add(new Person("李四",12)); list.add(new Person("王五",13)); list.add(new Person("赵六",14)); list.add(new Person("李雷",11)); list.add(new Person("韩梅梅",8)); list.add(new Person("jack",10)); //删除集合中年龄大于12的元素 /** * 之前迭代器的做法 * ListIterator it = list.listIterator(); * while (it.hasNext()){ * Person ele=it.next(); * if(ele.age>12){ * it.remove(); * } * } */ /** * lambda实现 * 逻辑 * 将集合中的每一个元素都带入到接口Predicate的test方法中, * 如果返回值是true,则删除这个元素 */ list.removeIf(ele->ele.age>10); System.out.println(list); } } ： 参数是T 返回值boolean // 在后续如果一个接口需要指定类型的参数,返回boolean时可以指向 Predicate // IntPredicate int -> boolean // LongPredicate long -> boolean // DoublePredicate double -> boolean // Consumer : 参数是T 无返回值(void) // IntConsumer int ->void // LongConsumer long ->void // DoubleConsumer double ->void // Function : 参数类型T 返回值R // IntFunction int -> R // LongFunction long -> R // DoubleFunction double -> R // IntToLongFunction int -> long // IntToDoubleFunction int -> double // LongToIntFunction long -> int // LongToDoubleFunction long -> double // DoubleToLongFunction double -> long // DoubleToIntFunction double -> int // Supplier : 参数 无 返回值T // UnaryOperator :参数T 返回值 T // BiFunction : 参数 T、U 返回值 R // BinaryOperator ：参数 T、T 返回值 T // BiPredicate : 参数T、U 返回值 boolean // BiConsumer : 参数T、U 无返回值 /** * 常用的 函数式接口 * Predicate、Consumer、Function、Supplier */ } } getNumber(){ int num=10; /** * Supplier supplier=()->num; * return supplier; */ return ()->{ return num; }; } } ************************************************************************* package com.alan.closure; import java.util.function.Consumer; /** * @author Alan * @version 1.0 * @date 2020-05-27 17:20 */ public class ClosureDemo2 { public static void main(String[] args) { int a=10; Consumer c=ele->{ System.out.println(a+1); //System.out.println(ele); //System.out.println(a++); 会报错 //在lambda中引用局部变量 这个变量必须是一个常量 }; //a++; 这样也会导致内部报错 //如果在内部已经引用局部变量 参数传递后 打印的还是 10 c.accept(1); } } 前言：
第二十章 多核编程
/home/dogs rover jack buster winston /home/cars rover jaguar ford 1 /home/dogs 3 /home/cars rover 1,3 jack 1 buster 1 winston 1 zorro 2 daisy 2 ford 3 前言
invokeBeanFactoryPostProcessors protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) { PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, this.getBeanFactoryPostProcessors()); if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean("loadTimeWeaver")) { beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory)); beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader())); } }
项目地址：https://github.com/jinyousen/blog/tree/master/problem/master-slave-switch THREAD_LOCAL = new ThreadLocal<>(); targetDataSources = new HashMap<>();
initHandlerMappings private void initHandlerMappings(ApplicationContext context) { this.handlerMappings = null; if (this.detectAllHandlerMappings) { Map matchingBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false); if (!matchingBeans.isEmpty()) { this.handlerMappings = new ArrayList(matchingBeans.values()); AnnotationAwareOrderComparator.sort(this.handlerMappings); } } else { try { HandlerMapping hm = (HandlerMapping)context.getBean("handlerMapping", HandlerMapping.class); this.handlerMappings = Collections.singletonList(hm); } catch (NoSuchBeanDefinitionException var3) { ; } } if (this.handlerMappings == null) { this.handlerMappings = this.getDefaultStrategies(context, HandlerMapping.class); if (this.logger.isTraceEnabled()) { this.logger.trace("No HandlerMappings declared for servlet '" + this.getServletName() + "': using default strategies from DispatcherServlet.properties"); } } } matchingBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerAdapter.class, true, false); if (!matchingBeans.isEmpty()) { this.handlerAdapters = new ArrayList(matchingBeans.values()); AnnotationAwareOrderComparator.sort(this.handlerAdapters); } } else { try { HandlerAdapter ha = (HandlerAdapter)context.getBean("handlerAdapter", HandlerAdapter.class); this.handlerAdapters = Collections.singletonList(ha); } catch (NoSuchBeanDefinitionException var3) { ; } } if (this.handlerAdapters == null) { this.handlerAdapters = this.getDefaultStrategies(context, HandlerAdapter.class); if (this.logger.isTraceEnabled()) { this.logger.trace("No HandlerAdapters declared for servlet '" + this.getServletName() + "': using default strategies from DispatcherServlet.properties"); } } }
看看 handlermapping 和 handleradapter都是怎么初始化的
Java是一种简单的,面向对象的,分布式的,解释型的,健壮安全的,结构中立的,可移植的,性能优异、多线程的静态语言。那么java语言的特点是什么呢？
最近在github上贡献源码修改的场合,碰见一个比较棘手的问题:fork开源代码到自己git空间上,在解决新的issue时,需要同步最新的代码到自己fork代码,继续在基础上开发,下面就介绍一下几种常见的方法: 删除原有项目,在重新fork。(这个比较耗费时间) 在电脑本地同时git clone原项目和fork项目,用git pull更新,然后对比,再git push到github上个人代码库。(也比较繁琐) 本地git clone已fork的项目,然后添加远程库为原项目地址。(注意点:要有项目访问权限) windows下的 github for desktop客户端.
.png)
大数据引擎.png)
大数据应用.png)
大数据底层技术.png)
ForeSpider软件
.png)
采集服务.png)
软件学习.png)
智能分析.png)
特征提取.png)
智能计算.png)
数据可视化.png)
数据分析应用.png)
系统集成服务.png)
代码工具.png)
金融方案.png)
制造业&物流.png)
企业数字化.png)
医疗方案.png)
政务方案.png)
实时监测.png)
智能分析.png)
数据智能挖掘.png)
全网自动采集.png)
场景智慧采集.png)
主题识别采集
022-2345 2937
185 2247 0110
business@forenose.com
022-2345 2937
185 2247 0110
business@forenose.com
前嗅大数据
津公网安备12010102001008号