解决_解决方案 - CSDN
精华内容
参与话题
  • Git:代码冲突常见解决方法

    万次阅读 多人点赞 2014-07-16 18:23:26
    如果系统中有一些配置文件在服务器上做了配置修改,然后后续开发又新添加一些配置项的时候,在发布这个配置文件的时候,会发生代码冲突:error: Your local changes to the following files would be overwritten by ...

    如果系统中有一些配置文件在服务器上做了配置修改,然后后续开发又新添加一些配置项的时候,

    在发布这个配置文件的时候,会发生代码冲突:

    error: Your local changes to the following files would be overwritten by merge:
            protected/config/main.php
    Please, commit your changes or stash them before you can merge.

    如果希望保留生产服务器上所做的改动,仅仅并入新配置项, 处理方法如下:

    git stash
    git pull
    git stash pop

    然后可以使用git diff -w +文件名 来确认代码自动合并的情况.


    反过来,如果希望用代码库中的文件完全覆盖本地工作版本. 方法如下:

    git reset --hard
    git pull

    其中git reset是针对版本,如果想针对文件回退本地修改,使用

    git checkout HEAD file/to/restore

    by iefreer

    展开全文
  • java.lang.IllegalStateException异常产生的原因及解决办法

    万次阅读 多人点赞 2014-02-27 10:35:49
    问题描述: 错误类型大致为以下几种: java.lang.IllegalStateException:Cannot forward a response that is already committed  IllegalStateException:response already commited  ...
    问题描述:
    

    错误类型大致为以下几种:

    java.lang.IllegalStateException:Cannot   forward   a   response   that   is   already   committed 
    IllegalStateException:response already commited 
    IllegalStateException:getOutputStream() has already been called for this request
    …………

     

    错误原因:

                           该异常表示,当前对客户端的响应已经结束,不能在响应已经结束(或说消亡)后再向

                           客户端(实际上是缓冲区)输出任何内容。

    具体分析:

                            首先解释下flush(),我们知道在使用读写流的时候数据先被读入内存这个缓冲区中,

                             然后再写入文件,但是当数据读完时不代表数据已经写入文件完毕,因为可能还有

                             一部分仍未写入文件而留在内存中,这时调用flush()方法就会把缓冲区的数据强行

                             清空输出,因此flush()的作用就是保证缓存清空输出。

                            response是服务端对客户端请求的一个响应,其中封装了响应头、状态码、内容等,

                            服务端在把response提交到客户端之前,会向缓冲区内写入响应头和状态码,然后

                            将所有内容flush。这就标志着该次响应已经committed(提交)。对于当前页面中

                            已经committed(提交)的response,就不能再使用这个response向缓冲区写任何东西

                         (注:同一个页面中的response.XXX()是同一个response的不同方法,只要其中一个

                            已经导致了committed,那么其它类似方式的调用都会导致 IllegalStateException异常)。

    【注意】能够导致响应已经committed的操作包括:forward, redirect, flushBuffer

    JDK API:

             

    flushBuffer

            public void flushBuffer()throws IOException
    Forces any content in the buffer to be written to the client. A call to this method automatically commits the response, meaning the status code and headers will be written.  
               ②
                    

    sendRedirect

             public void sendRedirect(String location)throws IOException
    Sends a temporary redirect response to the client using the specified redirect location URL. This method can accept relative URLs; the servlet container must convert the relative URL to an absolute URL before sending the response to the client. If the location is relative without a leading '/' the container interprets it as relative to the current request URI. If the location is relative with a leading '/' the container interprets it as relative to the servlet container root.

    If the response has already been committed, this method throws an IllegalStateException. After using this method, the response should be considered to be committed and should not be written to.

                ③                

    forward

    public void forward(ServletRequest request,ServletResponse response)
                                 throws ServletException,IOException
    Forwards a request from a servlet to another resource (servlet, JSP file, or HTML file) on the server. This method allows one servlet to do preliminary processing of a request and another resource to generate the response.

    For a RequestDispatcher obtained via getRequestDispatcher(), the ServletRequestobject has its path elements and parameters adjusted to match the path of the target resource.

    forward should be called before the response has been committed to the client (before response body output has been flushed). If the response already has been committed, this method throws anIllegalStateException. Uncommitted output in the response buffer is automatically cleared before the forward.

    The request and response parameters must be either the same objects as were passed to the calling servlet's service method or be subclasses of the ServletRequestWrapper orServletResponseWrapper classes that wrap them.

     

    备    注:

                      在一次响应commit之前,所有的内容输出都将写入servlet引擎的缓冲区(tomcat或

                      weblogic的内容空间), 而在commit之后,上一次response向缓冲区写入的内容,将清空。

                      由于servlet在没有设置单线程的情况下(使用Single-Threaded Model,servlet实现

                      SingleThreadModel接口,jsp使用<%@ page isThreadSafe="false" %>),是多线程的,所以

                      上面所说的缓冲区,都将是该response所属的线程私有的内存空间。有了这个概念,

                      将可以分析碰到的关于servlet多线程的很多问题。

                      如果不能确认response是否已经committed. 可以调用response.isCommitted()来判断。

                      导致这个错误最普遍的原因是,jsp有编译错误。

    常见解决办法:

                     ①在response.sendRedirect()方法后加return语句即可如下:
                           response.sendRedirect("login.jsp");
                           return;
                     检查提交的url是否有误。

                     如果你的页面中用了清缓存代码response.flushbuffer();又用到了response.sendRedirect(url);

                         你可以把response.flushbuffer();去掉,或者用JS的window.location.href="url";来做转向。

                     ④如果你用了OutputStream,而web容器生成的servlet代码中有out.write(””),这个和JSP中调用的

                         response.getOutputStream()冲突。out.write()这个是字符流,而response.getOutputStream()

                        是字节流,你不能在同一个页面中调用多个输出流。无论先调用哪一个,在调用第二个时都会抛出

                          IllegalStateException,因为在jsp中,out变量是通过response.getWriter得到的。在多个使用了

                         outputStream的<%%>语句之间不能有空格及多余的字符。也就是页面中除了使用了

                          outputStream的<%%>之外不能有空格或其它任何字符,在之内的语句可以有空格及回车。

                     在JSP页面做输出的时候有两种方式.一是通过JspWriter,另一个是通过

                     OutputStream,但二者互相排斥.如果并存的话就会报告以上异常.                     

                         在不得不使用OutputStream的时候.我们必须要把JspWriter舍弃掉了。找到

                         请求异常的页面所对应的Servlet..把其中所有使用JspWriter的语句全部去掉.

                         或者是到你的JSP文件里把动态输出的代码注释掉.这里注意换行和空格制表符

                         为JspWriter输出.应该一起去掉.保存文件重新启动服务器你会发现上述异常

                         消失了。                    

             由于jsp container在处理完成请求后会调用releasePageContet方法释放
              所用的PageContext object,并且同时调用getWriter方法,由于getWriter方法
              与在jsp页面中使用流相关的getOutputStream方法冲突,所以会造成这种异常,
             解决办法是:只需要在jsp页面的最后加上两条语句:  
                     out.clear(); 
                     out=pageContext.pushBody();
             即可(其中out,pageContext均为jsp内置对象!) 。
    展开全文
  • 缓存失效及解决方案

    千次阅读 2018-12-01 11:04:01
    这几天在网易云课堂上看到几个关于Java开发比较好的视频,推荐给大家 Java高级开发工程师公开课 这篇文章也是对其中一门课程的个人总结。 何谓缓存失效 对于一个并发量大的项目,缓存是必须的,如果没有缓存,...

    这几天在网易云课堂上看到几个关于Java开发比较好的视频,推荐给大家
    Java高级开发工程师公开课
    这篇文章也是对其中一门课程的个人总结。

    何谓缓存失效

    对于一个并发量大的项目,缓存是必须的,如果没有缓存,所有的请求将直击数据库,数据库很有可能抗不住,所以建立缓存势在不行。

    那么建立缓存后就有可能出现缓存失效的问题:

    1. 大面积的缓存key失效
    2. 热点key失效

    类似12306网站,因为用户频繁的查询车次信息,假设所有车次信息都建立对应的缓存,那么如果所有车次建立缓存的时间一样,失效时间也一样,那么在缓存失效的这一刻,也就意味着所有车次的缓存都失效。通常当缓存失效的时候我们需要重构缓存,这时所有的车次都将面临重构缓存,即出现问题1的场景,此时数据库就将面临大规模的访问。
    针对以上这种情况,可以将建立缓存的时间进行分布,使得缓存失效时间尽量不同,从而避免大面积的缓存失效。

    下面讨论第二个问题。
    春节马上快到了,抢票回家的时刻也快来临了。通常我们会事先选择好一个车次然后疯狂更新车次信息,假设此时这般车的缓存刚好失效,可以想象会有多大的请求会直怼数据库。

    使用缓存

    下面是通常的缓存使用方法,无非就是先查缓存,再查DB,重构缓存。

    @Service
    public class TicketService {
    
        @Autowired
        TicketRepository ticketRepository;
        
    
        @Autowired
        RedisUtil redis;
        public Integer findTicketByName(String name){
            //1.先从缓存获取
            String value = redis.get(name);
            if(value != null){
                System.out.println(Thread.currentThread().getId()+"从缓存获取:"+value);
                return Integer.valueOf(value);
            }
            //2.查询数据库
            Ticket ticket = ticketRepository.findByName(name);
            System.out.println(Thread.currentThread().getId()+"从数据库获取:"+ticket.getTickets());
            //3.放入缓存
            redis.set(name,ticket.getTickets(),120);
            return 0;
        }
    }
    

    接下来我们模拟1000个请求同时访问这个service

    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class RedisQpsApplicationTests {
    
        //车次
        public static final String NAME = "G2386";
    
        //请求数量
        public static final Integer THREAD_NUM = 1000;
    
        //倒计时
        private CountDownLatch countDownLatch = new CountDownLatch(THREAD_NUM);
        @Autowired
        private TicketService tocketService;
    
        @Autowired
        private TicketService2 tocketService2;
    
        @Autowired
        private TicketService3 tocketService3;
        @Test
        public void contextLoads() {
            long startTime = System.currentTimeMillis();
            System.out.println("开始测试");
            Thread[] threads = new Thread[THREAD_NUM];
            for(int i=0;i<THREAD_NUM;i++){
                threads[i] = new Thread(new Runnable() {
                    @Override
                    public void run() {
    
                        try {
                            //所有开启的线程在此等待,倒计时结束后统一开始请求,模拟并发量
                            countDownLatch.await();
                            //查找票数
                            tocketService.findTicketByName(NAME);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
    
                    }
                });
                threads[i].start();
                //倒计时
                countDownLatch.countDown();
            }
    
            for(Thread thread:threads){
                try {
                    thread.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("结束测试===="+(System.currentTimeMillis()-startTime));
        }
    
    }
    

    经过测试可以很简单地发现所有的访问都直接去查询数据库而获得数据
    在这里插入图片描述
    那么明明我们已经使用了缓存为什么还会出现这种情况呢?只要稍微了解多线程的知识就不难知道为什么会出现这个问题。
    我们的思路是第一个访问的人在没有缓存的情况下,去重构缓存,那么剩下的访问再去查缓存。上述的情况就是因为在第一人去查DB的时候,剩下的访问也去查DB了。
    那么根据我们的思路无非就是想让剩下的访问阻塞等待嘛,于是有了我们下面经过改良的方案。

    加锁重构缓存

    @Service
    public class TicketService2 {
    
        @Autowired
        TicketRepository ticketRepository;
    
        Lock lock = new ReentrantLock();
    
        @Autowired
        RedisUtil redis;
        public Integer findTicketByName(String name){
            //1.先从缓存获取
            String value = redis.get(name);
            if(value != null){
                System.out.println(Thread.currentThread().getId()+"从缓存获取:"+value);
                return Integer.valueOf(value);
            }
            //第一人获取锁,去查DB,剩余人二次查询缓存
            long s = System.currentTimeMillis();
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getId()+"加锁阻塞时长"+(System.currentTimeMillis()-s));
                value = redis.get(name);
                if(value != null){
                    System.out.println(Thread.currentThread().getId()+"从缓存获取:"+value);
                    return Integer.valueOf(value);
                }
                //2.查询数据库
                Ticket ticket = ticketRepository.findByName(name);
                System.out.println(Thread.currentThread().getId()+"从数据库获取:"+ticket.getTickets());
                //3.放入缓存
                redis.set(name,ticket.getTickets(),120);
            }finally {
                lock.unlock();
            }
    
            return 0;
        }
    }
    

    通过单元测试可以看到确实符合我们的预期。第一个去重构缓存,剩余的查缓存。这里要注意记得在锁内对缓存进行二次查询

    在这里插入图片描述
    这种解决方案怎么说呢,有好有坏。

    • 优点:简单通用,使用范围广
    • 缺点:阻塞访问,用户体验差,锁粒度粗

    关于锁的粒度:12306的车次是非常多的,假设有两个车次的缓存都失效了,假设使用上述方案,第一个车次的去查DB,第二个车次的也要去查DB重构缓存啊,凭什么我要等你第一个车次的查完,我再去查。这就是锁粒度粗导致的,一把锁面对所有车次的查询,当别车次拥有了锁,那你只好乖乖等待了。

    缓存降级

    缓存降级简单的理解就是降低预期期望。比如双十一的时候很多人因为支付不成功而提示的稍后再试,这些都属于缓存降级,缓存降级也有好几种方案,具体要结合实际业务场景,可以返回固定的信息,返回备份缓存的值(并不一定是真实值),返回提示等待…

    对锁的粒度进行优化结合缓存降级,对于每一个车次如果已经在重构缓存,那么同车次的访问进行缓存降级,不同车次的访问则也可以重构缓存。大体思路如下
    在这里插入图片描述
    下面使用ConcurrentHashMap对每个车次的锁进行标记

    @Service
    public class TicketService3 {
    
        @Autowired
        TicketRepository ticketRepository;
        //标记该车次是否有人在重构缓存
        ConcurrentHashMap<String,String> mapLock = new ConcurrentHashMap<>();
    
        @Autowired
        RedisUtil redis;
        public Integer findTicketByName(String name){
            //1.先从缓存获取
            String value = redis.get(name);
            if(value != null){
                System.out.println(Thread.currentThread().getId()+"从缓存获取:"+value);
                return Integer.valueOf(value);
            }
            boolean lock = false;
            try {
                /* putIfAbsent 如果不存在,添加键值,返回null,存在则返回存在的值 */
                lock = mapLock.putIfAbsent(name,"true") == null ;  //1000个请求,只有一个拿到锁,剩余人缓存降级
                if(lock){   //拿到锁
                    //2.查询数据库
                    Ticket ticket = ticketRepository.findByName(name);
                    System.out.println(Thread.currentThread().getId()+"从数据库获取:"+ticket.getTickets());
                    //3.放入缓存
                    redis.set(name,ticket.getTickets(),120);
                    //4.有备份缓存 双写缓存 不设时间
                }else{
                    //方案1 返回固定值
                    System.out.println(Thread.currentThread().getId()+"固定值获取:0");
                    return 0;
                    //方案2 备份缓存
                    //方案3 提示用户重试
                }
            }finally {
                if(lock){//有锁才释放
                    mapLock.remove(name);//释放锁
                }
    
            }
    
            return 0;
        }
    }
    

    详细代码已经见码云

    总结

    缓存失效的两种情况:
    1.大面积缓存key失效,所有车次查询都依赖数据库,可对缓存的时间进行随机分布
    2.热点key失效,某个key的海量请求直击数据库
    缓存的实现原理:先查缓存,再查DB,塞进缓存
    1.缓存失效:缓存有有效时间,当有效时间到达,大量并发线程会直击数据库。
    解决方案:1.Lock 第一人查DB,做缓存,剩余人二次查询缓存

    优点:简单有效,适用范围广
    缺点:阻塞其他线程,用户体验差
    锁颗粒度大
    优化:细粒度锁实现

    2.缓存降级:1)做备份缓存,不设置事件 2)返回固定值
    主备都无数据,一人去查DB,剩余人返回固定值
    主无数据,备有数据,一人查DB,剩余人查备份
    优点:灵活多变
    缺点:备份缓存数据可能不一致

    展开全文
  • Connection reset原因分析和解决方案

    万次阅读 多人点赞 2016-10-12 18:21:50
    Connection reset原因分析和解决方案
    最近线上总是在访问静态资源的时候间断性的报错,socket Connection reset,在环境、代码上花了大量时间没查个所以然,不得不使用强大的度娘,最后看了一篇开源博客里的文章写的不错,在这里转载下,希望可以帮助更多的童鞋解决这个困惑

    文章转自:https://my.oschina.net/xionghui/blog/508758

    在使用HttpClient调用后台resetful服务时,“Connection reset”是一个比较常见的问题,有同学跟我私信说被这个问题困扰很久了,今天就来分析下,希望能帮到大家。例如我们线上的网关日志就会抛该错误:


    从日志中可以看到是Socket套接字在read数据时抛出了该错误。


    导致“Connection reset”的原因是服务器端因为某种原因关闭了Connection,而客户端依然在读写数据,此时服务器会返回复位标志“RST”,然后此时客户端就会提示“java.net.SocketException: Connection reset”。

    可能有同学对复位标志“RST”还不太了解,这里简单解释一下:

    TCP建立连接时需要三次握手,在释放连接需要四次挥手;例如三次握手的过程如下:

    1. 第一次握手:客户端发送syn包(syn=j)到服务器,并进入SYN_SENT状态,等待服务器确认;

    2. 第二次握手:服务器收到syn包,并会确认客户的SYN(ack=j+1),同时自己也发送一个SYN包(syn=k),即SYN+ACK包,此时服务器进入SYN_RECV状态;

    3. 第三次握手:客户端收到服务器的SYN+ACK包,向服务器发送确认包ACK(ack=k+1),此包发送完毕,客户端和服务器进入ESTABLISHED(TCP连接成功)状态,完成三次握手。

    可以看到握手时会在客户端和服务器之间传递一些TCP头信息,比如ACK标志、SYN标志以及挥手时的FIN标志等。

    除了以上这些常见的标志头信息,还有另外一些标志头信息,比如推标志PSH、复位标志RST等。其中复位标志RST的作用就是“复位相应的TCP连接”。

    TCP连接和释放时还有许多细节,比如半连接状态、半关闭状态等。详情请参考这方面的巨著《TCP/IP详解》和《UNIX网络编程》。


    前面说到出现“Connection reset”的原因是服务器关闭了Connection[调用了Socket.close()方法]。大家可能有疑问了:服务器关闭了Connection为什么会返回“RST”而不是返回“FIN”标志。原因在于Socket.close()方法的语义和TCP的“FIN”标志语义不一样:发送TCP的“FIN”标志表示我不再发送数据了,而Socket.close()表示我不在发送也不接受数据了。问题就出在“我不接受数据” 上,如果此时客户端还往服务器发送数据,服务器内核接收到数据,但是发现此时Socket已经close了,则会返回“RST”标志给客户端。当然,此时客户端就会提示:“Connection reset”。详细说明可以参考oracle的有关文档:http://docs.oracle.com/javase/1.5.0/docs/guide/net/articles/connection_release.html


    另一个可能导致的“Connection reset”的原因是服务器设置了Socket.setLinger (true, 0)。但我检查过线上的tomcat配置,是没有使用该设置的,而且线上的服务器都使用了nginx进行反向代理,所以并不是该原因导致的。关于该原因上面的oracle文档也谈到了并给出了解释。


    此外啰嗦一下,另外还有一种比较常见的错误“Connection reset by peer”,该错误和“Connection reset”是有区别的:

    • 服务器返回了“RST”时,如果此时客户端正在从Socket套接字的输出流中读数据则会提示Connection reset”;

    • 服务器返回了“RST”时,如果此时客户端正在往Socket套接字的输入流中写数据则会提示“Connection reset by peer”。

    “Connection reset by peer”如下图所示:



    前面谈到了导致“Connection reset”的原因,而具体的解决方案有如下几种:

    • 出错了重试;

    • 客户端和服务器统一使用TCP长连接;

    • 客户端和服务器统一使用TCP短连接。

    首先是出错了重试:这种方案可以简单防止“Connection reset”错误,然后如果服务不是“幂等”的则不能使用该方法;比如提交订单操作就不是幂等的,如果使用重试则可能造成重复提单。


    然后是客户端和服务器统一使用TCP长连接:客户端使用TCP长连接很容易配置(直接设置HttpClient就好),而服务器配置长连接就比较麻烦了,就拿tomcat来说,需要设置tomcat的maxKeepAliveRequests、connectionTimeout等参数。另外如果使用了nginx进行反向代理或负载均衡,此时也需要配置nginx以支持长连接(nginx默认是对客户端使用长连接,对服务器使用短连接)。

    使用长连接可以避免每次建立TCP连接的三次握手而节约一定的时间,但是我这边由于是内网,客户端和服务器的3次握手很快,大约只需1ms。ping一下大约0.93ms(一次往返);三次握手也是一次往返(第三次握手不用返回)。根据80/20原理,1ms可以忽略不计;又考虑到长连接的扩展性不如短连接好、修改nginx和tomcat的配置代价很大(所有后台服务都需要修改);所以这里并没有使用长连接。ping服务器的时间如下图:



    最后的解决方案是客户端和服务器统一使用TCP短连接:我这边正是这么干的,而使用短连接既不用改nginx配置,也不用改tomcat配置,只需在使用HttpClient时使用http1.0协议并增加http请求的header信息(Connection: Close),源码如下:

    httpGet.setProtocolVersion(HttpVersion.HTTP_1_0);
    httpGet.addHeader(HTTP.CONN_DIRECTIVE, HTTP.CONN_CLOSE);

    最后再补充几句,虽然对于每次请求TCP长连接只能节约大约1ms的时间,但是具体是使用长连接还是短连接还是要衡量下,比如你的服务每天的pv是1亿,那么使用长连接节约的总时间为:
    1亿*1ms=10^8*1ms=10^5*1s=27.78h

    神奇的是,亿万级pv的服务使用长连接一天内节约的总时间为27.78小时(竟然大于一天),所以使用长连接还是短连接大家需要根据自己的服务访问量、扩展性等因素衡量下。但是一定要注意:服务器和客户端的连接一定要保持一致,要么都是长连接,要么都是短连接。

    展开全文
  • Beyond Compare4过期解决方法

    万次阅读 多人点赞 2019-05-06 09:59:55
    修改注册表 1、在搜索栏中输入 regedit,打开注册表 2、删除项目CacheId : HKEY_CURRENT_USER\Software\Scooter Software\Beyond Compare 4\CacheId
  • Connection reset 异常原因及解决

    万次阅读 2018-12-07 09:26:25
    第三方访问外网提供的接口,出现Connection reset 异常,自己调用外网接口无问题,第三方调不通 最后发现原因为第三方使用的jdk版本为1.7,而我们使用的是1.8,jdk... 解决方法:在nginx中nginx.conf文件中设置ssl...
  • 超卖问题解决

    千次阅读 2019-03-12 20:42:30
    本项目超卖有两种: 1. 不同用户在读请求的时候,发现商品库存足够,然后同时发起请求,进行秒杀操作,减库存,导致库存减为负数。 2. 同一用户在有库存的时候,连续发出多个请求,两个请求同时存在,于是生成了多...
  • 列表和元组 列表和元组的区别是显然的:列表是动态的,其大小可以该标;而元组是不可变的,一旦创建就不能修改。 实现细节 python中的列表的英文名是list,因此很容易和其它语言(C++, Java等)标准库中常见的链表混淆...
  • 转自 PheonixHkbxoic 的《前端解决跨域问题的8种方案(最新最全)》 原址:https://www.cnblogs.com/PheonixHkbxoic/p/5760838.html 1.同源策略如下: URL 说明 是否允许通信 http://www.a.com/a.js ...
  • android 兼容所有刘海屏的方案大全

    万次阅读 2018-06-14 11:26:29
    刘海屏解决方案,谷歌官方提供的解决方案,小米xiaomi官方提供的解决方案,华为huawei官方提供的解决方案,vivo官方提供的解决方案,oppo官方提供的解决方案,其它手机厂商,ios刘海屏解决方案,兼容ios刘海屏
  • win7或win2008系统中,出现【已停止工作,联机检查解决方案并关闭该程序,关闭程序】解决方法! 经过摸索,点击【控制面板】-【操作中心】-【更改操作中心设置】-【问题报告设置】-【从不检查解决方案(不推荐)】 ...
  • 1.如下,状态时已关闭,但是解决结果是未解决 . 2.解决方法: 2.1设置-问题-工作流,找到目前在使用的工作流,点击编辑 3.找到要使问题变为已解决的操作,如测试人员验收问题时,如果进行通过的操作,则...
  •  vs ide一个解决方案是可以加入多个项目的
  • VS---“重新生成解决方案”和"生成解决方案"的学习

    万次阅读 热门讨论 2016-04-30 22:09:54
     项目进行过程中,每次更新代码之后会去点击“生成解决方案”或者“重新生成解决方案”,也疑虑过这两个选项之间的细微差别,通过上网查询,做如下简单总结。 【概念理解】  重新生成:  重新生成解决方案...
  • C#程序终止问题CLR20R3解决方法

    万次阅读 2017-02-07 20:29:12
    去年在公司局域网部署了一个C#编写的自动更新的工具软件,最近有同事反映部分Win7系统电脑安装... 找度娘,找必应,一大堆解决方法,一个个尝试,没有解决,最后都快放弃, 想起了老大说过的一句话,问题实在解决不了
  • SVN版本冲突解决详解

    万次阅读 多人点赞 2009-11-23 16:04:00
    版本冲突原因:假设A、B两个用户都在版本号为100的时候,更新了kingtuns.txt这个文件,A用户在修改完成之后提交kingtuns.txt到服务器,这个时候提交成功,这个时候kingtuns.txt文件的版本号已经变成101了。...
  • eclipse 中git解决冲突

    万次阅读 多人点赞 2013-12-02 10:31:25
    1、工程->Team->同步:  2、从远程pull至本地,就会出现如下内容:  3、使用Merge Tool,执行第二项 ... 5、冲突文件变为修改图标样式,再提交至本地,此时的提交
  • SourceTree解决冲突的三种情形

    万次阅读 2018-09-18 10:20:14
    SourceTree解决冲突的三种情形 解决冲突的时候,操作已暂存文件,不操作未暂存文件(开始的时候,这两个区域的文件是一样的,并且都带有感叹号提示); 使用他人版本解决冲突,会自动将当前分支对应文档更改成他人...
  • 此时可能因为一些引用问题想打开Nuget包管理器,会弹出如下提示:解决方案未保存,请先保存你的解决方案,然后再管理Nuget包此时只需保存项目,就可看到即将保存的文件是.sln后缀的文件。保存后打开该.sln文件来打开...
  • 彻底解决tomcat中文乱码问题的终极方案

    万次阅读 多人点赞 2020-08-31 10:16:55
    这几天测试的兄弟发现了项目中存在乱码问题 经过排查发现是tomcat中的...终极解决方法:在C:\apache-tomcat-8.5.30\bin\catalina.bat文件中加了如下一条语句彻底解决乱码了 注:这种方法可能只适用一部分问题! ...
1 2 3 4 5 ... 20
收藏数 7,125,204
精华内容 2,850,081
关键字:

解决