miki艾比利的博客

愿居于一城,与卿所见美好......

您现在的位置是:首页>漫生活

    9种设计模式在Spring中的运用,一定要非常熟练!

    作者:miki艾比利分类:[javaEE]浏览(532评论(0

    1.简单工厂(非23种设计模式中的一种)

    • 实现方式:BeanFactory。 Spring中的BeanFactory就是简单工厂模式的体现,根据传入一个唯一的标识来获得Bean对象,但是否是在传入参数后创建还是传入参数前创建这个要根据具体情况来定。
    • 实质:由一个工厂类根据传入的参数,动态决定应该创建哪一个产品类。
    • 实现原理:
      • bean容器的启动阶段:
        • 读取bean的xml配置文件,将bean元素分别转换成一个BeanDefinition对象。
        • 然后通过BeanDefinitionRegistry将这些bean注册到beanFactory中,保存在它的一个ConcurrentHashMap中。
        • 将BeanDefinition注册到了beanFactory之后,在这里Spring为我们提供了一个扩展的切口,允许我们通过实现接口BeanFactoryPostProcessor 在此处来插入我们定义的代码。典型的例子就是:PropertyPlaceholderConfigurer,我们一般在配置数据库的dataSource时使用到的占位符的值,就是它注入进去的。
      • 容器中bean的实例化阶段:
        实例化阶段主要是通过反射或者CGLIB对bean进行实例化,在这个阶段Spring又给我们暴露了很多的扩展点:
        • 各种的Aware接口,比如 BeanFactoryAware,对于实现了这些Aware接口的bean,在实例化bean时Spring会帮我们注入对应的BeanFactory的实例。
        • BeanPostProcessor接口,实现了BeanPostProcessor接口的bean,在实例化bean时Spring会帮我们调用接口中的方法。
        • InitializingBean接口,实现了InitializingBean接口的bean,在实例化bean时Spring会帮我们调用接口中的方法。
        • DisposableBean接口,实现了BeanPostProcessor接口的bean,在该bean死亡时Spring会帮我们调用接口中的方法。
    • 设计意义:
      • 松耦合。可以将原来硬编码的依赖,通过Spring这个beanFactory这个工长来注入依赖,也就是说原来只有依赖方和被依赖方,现在我们引入了第三方——spring这个beanFactory,由它来解决bean之间的依赖问题,达到了松耦合的效果.
      • bean的额外处理。通过Spring接口的暴露,在实例化bean的阶段我们可以进行一些额外的处理,这些额外的处理只需要让bean实现对应的接口即可,那么spring就会在bean的生命周期调用我们实现的接口来处理该bean。[非常重要]

    2.工厂方法

    • 实现方式:FactoryBean接口。
    • 实现原理:
      实现了FactoryBean接口的bean是一类叫做factory的bean。其特点是,spring会在使用getBean()调用获得该bean时,会自动调用该bean的getObject()方法,所以返回的不是factory这个bean,而是这个bean.getOjbect()方法的返回值。
    • 例子:
      • 典型的例子有spring与mybatis的结合。
      • 代码示例

      • 说明:
        我们看上面该bean,因为实现了FactoryBean接口,所以返回的不是 SqlSessionFactoryBean 的实例,而是她的 SqlSessionFactoryBean.getObject() 的返回值。

    3.单例模式

    • Spring依赖注入Bean实例默认是单例的。
    • Spring的依赖注入(包括lazy-init方式)都是发生在AbstractBeanFactory的getBean里。getBean的doGetBean方法调用getSingleton进行bean的创建。
    • 分析getSingleton()方法

      public Object getSingleton(String beanName){
          //参数true设置标识允许早期依赖
          return getSingleton(beanName,true);
      }
      protected Object getSingleton(String beanName, boolean allowEarlyReference) {
          //检查缓存中是否存在实例
          Object singletonObject = this.singletonObjects.get(beanName);
          if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
              //如果为空,则锁定全局变量并进行处理。
              synchronized (this.singletonObjects) {
                  //如果此bean正在加载,则不处理
                  singletonObject = this.earlySingletonObjects.get(beanName);
                  if (singletonObject == null && allowEarlyReference) {  
                      //当某些方法需要提前初始化的时候则会调用addSingleFactory 方法将对应的ObjectFactory初始化策略存储在singletonFactories
                      ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                      if (singletonFactory != null) {
                          //调用预先设定的getObject方法
                          singletonObject = singletonFactory.getObject();
                          //记录在缓存中,earlysingletonObjects和singletonFactories互斥
                          this.earlySingletonObjects.put(beanName, singletonObject);
                          this.singletonFactories.remove(beanName);
                      }
                  }
              }
          }
          return (singletonObject != NULL_OBJECT ? singletonObject : null);
      }
      
      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • getSingleton()过程图
        ps:spring依赖注入时,使用了 双重判断加锁 的单例模式
        这里写图片描述
      • 总结
      • 单例模式定义:保证一个类仅有一个实例,并提供一个访问它的全局访问点。
      • spring对单例的实现:spring中的单例模式完成了后半句话,即提供了全局的访问点BeanFactory。但没有从构造器级别去控制单例,这是因为spring管理的是任意的java对象。

    4. 适配器模式

    • 实现方式:SpringMVC中的适配器HandlerAdatper。
    • 实现原理:HandlerAdatper根据Handler规则执行不同的Handler。
    • 实现过程:
      DispatcherServlet根据HandlerMapping返回的handler,向HandlerAdatper发起请求,处理Handler。HandlerAdapter根据规则找到对应的Handler并让其执行,执行完毕后Handler会向HandlerAdapter返回一个ModelAndView,最后由HandlerAdapter向DispatchServelet返回一个ModelAndView。
    • 实现意义:
      HandlerAdatper使得Handler的扩展变得容易,只需要增加一个新的Handler和一个对应的HandlerAdapter即可。因此Spring定义了一个适配接口,使得每一种Controller有一种对应的适配器实现类,让适配器代替controller执行相应的方法。这样在扩展Controller时,只需要增加一个适配器类就完成了SpringMVC的扩展了。

    5.装饰器模式

    • 实现方式:
      Spring中用到的包装器模式在类名上有两种表现:一种是类名中含有Wrapper,另一种是类名中含有Decorator。
    • 实质:
      • 动态地给一个对象添加一些额外的职责。
      • 就增加功能来说,Decorator模式相比生成子类更为灵活。

    6.代理模式

    • 实现方式: AOP底层,就是动态代理模式的实现。
      • 动态代理:在内存中构建的,不需要手动编写代理类
      • 静态代理:需要手工编写代理类,代理类引用被代理对象。
    • 实现原理:
      切面在应用运行的时刻被织入。一般情况下,在织入切面时,AOP容器会为目标对象创建动态的创建一个代理对象。SpringAOP就是以这种方式织入切面的。
      织入:把切面应用到目标对象并创建新的代理对象的过程。

    7.观察者模式

    • 实现方式:spring的事件驱动模型使用的是 观察者模式 ,Spring中Observer模式常用的地方是listener的实现。
    • 具体实现:
      事件机制的实现需要三个部分,事件源,事件,事件监听器

      • ApplicationEvent抽象类[事件]

        • 继承自jdk的EventObject,所有的事件都需要继承ApplicationEvent,并且通过构造器参数source得到事件源.
        • 该类的实现类ApplicationContextEvent表示ApplicaitonContext的容器事件.
        • 代码:

          public abstract class ApplicationEvent extends EventObject {
              private static final long serialVersionUID = 7099057708183571937L;
              private final long timestamp;
              public ApplicationEvent(Object source) {
              super(source);
              this.timestamp = System.currentTimeMillis();
              }
              public final long getTimestamp() {
                  return this.timestamp;
              }
          }
          
          • 1
          • 2
          • 3
          • 4
          • 5
          • 6
          • 7
          • 8
          • 9
          • 10
          • 11
      • ApplicationListener接口[事件监听器]

        • 继承自jdk的EventListener,所有的监听器都要实现这个接口。
        • 这个接口只有一个onApplicationEvent()方法,该方法接受一个ApplicationEvent或其子类对象作为参数,在方法体中,可以通过不同对Event类的判断来进行相应的处理。
        • 当事件触发时所有的监听器都会收到消息。
        • 代码:

              public interface ApplicationListener<E extends ApplicationEvent> extends                EventListener {
                           void onApplicationEvent(E event);
          } 
          
          • 1
          • 2
          • 3
      • ApplicationContext接口[事件源]

        • ApplicationContext是spring中的全局容器,翻译过来是”应用上下文”。
        • 实现了ApplicationEventPublisher接口。
        • 职责:负责读取bean的配置文档,管理bean的加载,维护bean之间的依赖关系,可以说是负责bean的整个生命周期,再通俗一点就是我们平时所说的IOC容器。
        • 代码:

          public interface ApplicationEventPublisher {
                  void publishEvent(ApplicationEvent event);
          }   
          
          public void publishEvent(ApplicationEvent event) {
              Assert.notNull(event, "Event must not be null");
              if (logger.isTraceEnabled()) {
                   logger.trace("Publishing event in " + getDisplayName() + ": " + event);
              }
              getApplicationEventMulticaster().multicastEvent(event);
              if (this.parent != null) {
              this.parent.publishEvent(event);
              }
          }
          
          • 1
          • 2
          • 3
          • 4
          • 5
          • 6
          • 7
          • 8
          • 9
          • 10
          • 11
          • 12
          • 13
          • 14
      • ApplicationEventMulticaster抽象类[事件源中publishEvent方法需要调用其方法getApplicationEventMulticaster]

        • 属于事件广播器,它的作用是把Applicationcontext发布的Event广播给所有的监听器.
        • 代码:

          public abstract class AbstractApplicationContext extends DefaultResourceLoader
              implements ConfigurableApplicationContext, DisposableBean {  
              private ApplicationEventMulticaster applicationEventMulticaster;  
              protected void registerListeners() {  
              // Register statically specified listeners first.  
              for (ApplicationListener<?> listener : getApplicationListeners()) {  
              getApplicationEventMulticaster().addApplicationListener(listener);  
              }  
              // Do not initialize FactoryBeans here: We need to leave all regular beans  
              // uninitialized to let post-processors apply to them!  
              String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);  
              for (String lisName : listenerBeanNames) {  
              getApplicationEventMulticaster().addApplicationListenerBean(lisName);  
              }  
            }  
          }
          
          • 1
          • 2
          • 3
          • 4
          • 5
          • 6
          • 7
          • 8
          • 9
          • 10
          • 11
          • 12
          • 13
          • 14
          • 15
          • 16

    8.策略模式

    • 实现方式:Spring框架的资源访问Resource接口 。该接口提供了更强的资源访问能力,Spring 框架本身大量使用了 Resource 接口来访问底层资源。
    • Resource 接口介绍
      • source 接口是具体资源访问策略的抽象,也是所有资源访问类所实现的接口。
      • Resource 接口主要提供了如下几个方法:
        • getInputStream():定位并打开资源,返回资源对应的输入流。每次调用都返回新的输入流。调用者必须负责关闭输入流。
        • exists():返回 Resource 所指向的资源是否存在。
        • isOpen():返回资源文件是否打开,如果资源文件不能多次读取,每次读取结束应该显式关闭,以防止资源泄漏。
        • getDescription():返回资源的描述信息,通常用于资源处理出错时输出该信息,通常是全限定文件名或实际 URL。
        • getFile:返回资源对应的 File 对象。
        • getURL:返回资源对应的 URL 对象。
          最后两个方法通常无须使用,仅在通过简单方式访问无法实现时,Resource 提供传统的资源访问的功能。
      • Resource 接口本身没有提供访问任何底层资源的实现逻辑,针对不同的底层资源,Spring 将会提供不同的 Resource 实现类,不同的实现类负责不同的资源访问逻辑。
      • Spring 为 Resource 接口提供了如下实现类:
        • UrlResource:访问网络资源的实现类。
        • ClassPathResource:访问类加载路径里资源的实现类。
        • FileSystemResource:访问文件系统里资源的实现类。
        • ServletContextResource:访问相对于 ServletContext 路径里的资源的实现类.
        • InputStreamResource:访问输入流资源的实现类。
        • ByteArrayResource:访问字节数组资源的实现类。
          这些 Resource 实现类,针对不同的的底层资源,提供了相应的资源访问逻辑,并提供便捷的包装,以利于客户端程序的资源访问。

    9.模版方法模式

    • 经典模板方法定义:
      • 父类定义了骨架(调用哪些方法及顺序),某些特定方法由子类实现
      • 最大的好处:代码复用,减少重复代码。除了子类要实现的特定方法,其他方法及方法调用顺序都在父类中预先写好了。
      • 所以父类模板方法中有两类方法:
        • 共同的方法:所有子类都会用到的代码
        • 不同的方法:子类要覆盖的方法,分为两种:
          • 抽象方法:父类中的是抽象方法,子类必须覆盖
          • 钩子方法:父类中是一个空方法,子类继承了默认也是空的
            注:为什么叫钩子,子类可以通过这个钩子(方法),控制父类,因为这个钩子实际是父类的方法(空方法)!
    • Spring模板方法模式实质:
      是模板方法模式和回调模式的结合,是Template Method不需要继承的另一种实现方式。Spring几乎所有的外接扩展都采用这种模式。
    • 具体实现:
      JDBC的抽象和对Hibernate的集成,都采用了一种理念或者处理方式,那就是模板方法模式与相应的Callback接口相结合。
    • 采用模板方法模式是为了以一种统一而集中的方式来处理资源的获取和释放,以JdbcTempalte为例:

      public abstract class JdbcTemplate {  
           public final Object execute(String sql){  
              Connection con=null;  
              Statement stmt=null;  
              try{  
                  con=getConnection();  
                  stmt=con.createStatement();  
                  Object retValue=executeWithStatement(stmt,sql);  
                  return retValue;  
              }catch(SQLException e){  
                   ...  
              }finally{  
                  closeStatement(stmt);  
                  releaseConnection(con);  
              }  
          }   
          protected abstract Object executeWithStatement(Statement   stmt, String sql);  
      }  
      
      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
    • 引入回调原因:

      • JdbcTemplate是抽象类,不能够独立使用,我们每次进行数据访问的时候都要给出一个相应的子类实现,这样肯定不方便,所以就引入了回调 。
      • 回调代码

        public interface StatementCallback{  
            Object doWithStatement(Statement stmt);  
        }   
        
        • 1
        • 2
        • 3
      • 利用回调方法重写JdbcTemplate方法

        public class JdbcTemplate {  
            public final Object execute(StatementCallback callback){  
                Connection con=null;  
                Statement stmt=null;  
                try{  
                    con=getConnection();  
                    stmt=con.createStatement();  
                    Object retValue=callback.doWithStatement(stmt);  
                    return retValue;  
                }catch(SQLException e){  
                    ...  
                }finally{  
                    closeStatement(stmt);  
                    releaseConnection(con);  
                }  
            }  
        
            ...//其它方法定义  
        }   
        
        • 1
        • 2
        • 3
        • 4
        • 5
        • 6
        • 7
        • 8
        • 9
        • 10
        • 11
        • 12
        • 13
        • 14
        • 15
        • 16
        • 17
        • 18
        • 19
      • Jdbc使用方法如下:

        JdbcTemplate jdbcTemplate=...;  
            final String sql=...;  
            StatementCallback callback=new StatementCallback(){  
            public Object=doWithStatement(Statement stmt){  
                return ...;  
            }  
        }    
        jdbcTemplate.execute(callback);  
        
        • 1
        • 2
        • 3
        • 4
        • 5
        • 6
        • 7
        • 8
    • 为什么JdbcTemplate没有使用继承?
      因为这个类的方法太多,但是我们还是想用到JdbcTemplate已有的稳定的、公用的数据库连接,那么我们怎么办呢?我们可以把变化的东西抽出来作为一个参数传入JdbcTemplate的方法中。但是变化的东西是一段代码,而且这段代码会用到JdbcTemplate中的变量。怎么办?那我们就用回调对象吧。在这个回调对象中定义一个操纵JdbcTemplate中变量的方法,我们去实现这个方法,就把变化的东西集中到这里了。然后我们再传入这个回调对象到JdbcTemplate,从而完成了调用。

      参考:
      https://www.cnblogs.com/digdeep/p/4518571.html
      https://www.cnblogs.com/tongkey/p/7919401.html
      https://www.cnblogs.com/fingerboy/p/6393644.html
      https://blog.csdn.net/ovoo_8/article/details/51189401
      https://blog.csdn.net/z69183787/article/details/65628166

      《spring源码深度分析》

    全文
2020-12-08 10:30:46

    【转载】ExecutorService的正确关闭方法

    作者:miki艾比利分类:[javaEE]浏览(521评论(0

    ExecutorService的正确关闭方法

    转自:https://blog.csdn.net/xueyepiaoling/article/details/61200270

    虽然使用ExecutorService可以让线程处理变的很简单,可是有没有人觉得在结束线程运行时候只调用shutdown方法就可以了?实际上,只调用shutdown方法的是不够的。我们用学校的老师和学生的关系来说明这个问题。

    shutdown只是起到通知的作用

    我们来假设如下场景:
    学校里在课上老师出了一些问题安排全班同学进行解答并对学生说“开问题解答完毕后请举手示意!”
    如果有学生解答完毕后会举手对老师说“老师我做完了!”,如果大家都解题完毕后上课结束。

    上面的场景对应于ExecutorService里的方法的话是下面的样子。

    • 老师: ExecutorService
    • 学生: ExecutorService里的线程
    • 问题: 通过参数传递给ExecutorService.execute的任务(Runnable)
    • 授课: main线程
    • 学校: Java进程
    • “问题解答完毕后请举手示意!”是shutdown方法。
    • “老师我做完了!”是各个任务(Runnable)的运行结束。

    所有的任务(Runnable)都结束了的话main线程(授课)也结束了。

    在这里,我们假设试卷中有难度较大的问题,当然学生解答较难的问题也会比较花时间。在上面的场景中老师除了shutdown方法之外什么也做不了,只能呆呆得等着学生们说,“老师我做完了!”之后才可以有下一步动作。这都是因为shutdown方法只是用来通知的方法。

    这时如果即使授课时间结束(main线程结束),学校也不能放学(Java进程结束),因为学生们还在解题中呢。这个时候如果你是老师你会怎么做?

    一般的情况肯定是经过一定的时间在授课快要结束的时候,如果还有人没有解答出来的话,或者公布给大家解题方法,或者作为课后习题让学生回去继续思考,然后结束上课对不对!

    定好下课时间后等待结束

    如果经过了一定的时间任务(Runnable)还不结束的时候我们可以通过中止任务(Runnable)的执行,以防止一直等待任务的结束。awaitTermination方法正是可以实现这个中止作用的角色。

    具体的使用方法是,在shutdown方法调用后,接着调用awaitTermination方法。这时只需要等待awaitTermination方法里第一个参数指定的时间。

    如果在指定的时间内所有的任务都结束的时候,返回true,反之返回false。返回false意味着课程结束的时候还有题目没有解答出来的学生。

    通过shutdownNow方法,我们可以作为老师向同学发出“没有解答出来的同学明天给出解答”的命令后结束授课。

    shutdownNow方法的作用是向所有执行中的线程发出interrupted以中止线程的运行。这时,各个线程会抛出InterruptedException异常(前提是
    线程中运行了sleep等会抛出异常的方法)

    所以正确的中止线程的方法如下:

    public static void main(String[] args) {  
       
        ExecutorService pool = Executors.newFixedThreadPool(5);  
        final long waitTime = 8 * 1000;  
        final long awaitTime = 5 * 1000;  
       
        Runnable task1 = new Runnable(){  
            public void run(){  
                try {  
                    System.out.println("task1 start");  
                    Thread.sleep(waitTime);  
                    System.out.println("task1 end");  
                } catch (InterruptedException e) {  
                    System.out.println("task1 interrupted: " + e);  
                }  
            }  
        };  
       
        Runnable task2 = new Runnable(){  
            public void run(){  
                try {  
                    System.out.println("task2 start");  
                    Thread.sleep(1000);  
                    System.out.println("task2 end");  
                } catch (InterruptedException e) {  
                    System.out.println("task2 interrupted: " + e);  
                }  
            }  
        };  
        // 让学生解答某个很难的问题  
        pool.execute(task1);  
       
        // 让学生解答很多问题  
        for(int i=0; i<1000; ++i){  
            pool.execute(task2);  
        }  
       
        try {  
            // 向学生传达“问题解答完毕后请举手示意!”  
            pool.shutdown();  
       
            // 向学生传达“XX分之内解答不完的问题全部带回去作为课后作业!”后老师等待学生答题  
            // (所有的任务都结束的时候,返回TRUE)  
            if(!pool.awaitTermination(awaitTime, TimeUnit.MILLISECONDS)){  
                // 超时的时候向线程池中所有的线程发出中断(interrupted)。  
                pool.shutdownNow();  
            }  
        } catch (InterruptedException e) {  
            // awaitTermination方法被中断的时候也中止线程池中全部的线程的执行。  
            System.out.println("awaitTermination interrupted: " + e);  
            pool.shutdownNow();  
        }  
       
        System.out.println("end");  
    }  
    

    可以看出上面程序中waitTime的值比awaitTime大的情况下,发生Timeout然后执行中的线程会中止执行而结束。

    反过来如果缩小waitTime的值,增大awaitTime的值的的话,各个线程就会不被中止的正常运行至结束。

    在这里,如果我们把awaitTime和shutdownNow方法全部屏蔽掉的只留下shutdown方法的话会怎样呢? 会变成表示main方法结束的「end」显示出来之后,会打印出很多的task2的start和end。这就是虽然课程结束了,但是学校仍然不能放学的不正常状态。最恶劣的情况会导致JAVA进程一直残留在OS中。

    所以我们一定不要忘记使用awaitTermination和shutdownNow。

    shutdown也是很重要的

    看了上面的描述后可能有些人会认为,只需要执行awaitTermination和shutdownNow就可以正常结束线程池中的线程了。其实不然。
    shutdown方法还有「大家只解答我要求的问题,其它的不用多做」的意思在里面。

    shutdown方法调用后,就不能再继续使用ExecutorService来追加新的任务了,如果继续调用execute方法执行新的任务的话,就会抛出RejectedExecutionException异常。(submit方法也会抛出上述异常)

    而且,awaitTermination方法也不是在它被调用的时间点上简单得等待任务结束而是在awaitTermination方法调用后,持续监视各个任务的状态以或者是否线程已经运行结束。所以不调用shutdown方法执行调用awaitTermination的话由于追加出来的任务可能会导致任务状态监视出现偏差而发生预料之外的awaitTermination的Timeout异常。

    所以正确的调用顺序是:

    shutdown方法
    awaitTermination方法
    shutdownNow方法(发生异常或者是Timeout的时候)
    

    实际开发的系统可能会有不能强制线程中止执行的场景出现,所以虽然推荐使用上面说的调用顺序但也并不是绝对一成不变的。

    全文
2019-10-25 19:33:30

    解决getConnection或者java.sql.rs.next() 时,线程hang住,导致代码卡顿问题

    作者:miki艾比利分类:[javaEE]浏览(463评论(0

    1. 问题复现

    当你兴高采烈的写完一堆获取数据库连接的代码准备测试时,由于服务器性能,或者网络问题,导致线程阻塞,页面卡死。大多数数据库可能会具备连接超时的设置,你可以设置一下连接超时,自动退出即可。但是,有的数据库就是那么尿性,又或者是本身提供的jdbc驱动不支持连接超时设置,这个时候就很头疼了,每次页面查询数据或者点击测试连接的时候,让前台写一堆ajax超时设置吗,好了,废话不多说,此处教你一个方法,使用java中的ExecutorService来实现任务的中止。

    ExecutorService简介:

    查看java的api可知,

    继承于Executor,提供了管理终止的方法和可以生成Future,用来跟踪一个或多个异步任务进度的方法。

    可以关闭Service,之后会拒绝执行新的任务。提供了两种终止方法,shutdown()会终止任务,但是shutdown()之前提交的任务会继续执行,而shutdownNow()会终止掉没启动的任务并且终止正在运行的任务。终止的时候如果没有提交的任务,没有等待的任务,没有正在执行的任务时,应该释放executor资源。

    总的来说,实现ExecutorService,就有终止任务,和生成Future跟踪任务的能力。

    3.代码

    下面上代码:

    public static void main(String[] args) {
    		
    		boolean hasNext = false;
    		
    		Runnable runnable = new Runnable() {
                public void run() {
                    try {
                       Thread.sleep(5000);
                       System.out.println("乐乐");
                    } catch (Throwable e) {
                        
                    }
                }
            };
    //      Thread thread = new Thread(runnable);
    //      thread.start();
            
            System.out.println("tomcat初始化..");
            System.out.println("开始时间:"+System.currentTimeMillis());
            
            //首先构造Executor接口,下面的例子是创建一个单线程的执行者,你也可以根据需要创建基于线程池的执行者
            ExecutorService executor = Executors.newSingleThreadExecutor();
            
            //将rs.next()或者getcConnection方法委托给Callable接口去调用,通过Future接口获取返回结果
    		FutureTask future = new FutureTask(new Callable() {
    			public Boolean call() throws IOException {
    				try {
    					//模拟超时
    					Thread.sleep(5000);
    				} catch (InterruptedException e) {
    					e.printStackTrace();return false;
    				}
    				System.out.println("获取连接成功..");
    				return true;
    			}
    		});
    		
    		try {
    			executor.execute(future);
    			hasNext = future.get(2, TimeUnit.SECONDS);
    		} catch (InterruptedException | ExecutionException | TimeoutException e) {
    			e.printStackTrace();
    			System.out.println("超时啦...");
    			//捕获异常后,关闭当前任务!!!重要  2019.10.24  miki
    			executor.shutdown();
    		}       
            if(hasNext) {
            	//System.out.println("到达时间:"+System.currentTimeMillis());
            	System.out.println("到达时间:"+System.currentTimeMillis());
            }      
            
    	}

    执行结果如下:

    注意如下:

    shutdown()

    不能添加新任务,否则抛异常。但是已存在的任务会继续执行完成。(所以才会打印出来获取链接成功

    shutdownNow()

    不接收新任务,不处理等待任务,尝试中断已存在线程(通过Thread.interrupt(),这个方法作用有限,你的任务里没有抛出InterruptException的话,就中断不了了)

    Future submit(Callable task);

    Future submit(Runnable task, T result);

    谢谢观看,记得掉个赞哦

     

    全文
2019-10-24 21:19:07

    【转载】阿里资深工程师教你如何优化 Java 代码!

    作者:miki艾比利分类:[javaEE]浏览(1523评论(0

    作者 | 王超

    责编 | 伍杏玲

    明代王阳明先生在《传习录》谈为学之道时说:

    私欲日生,如地上尘,一日不扫,便又有一层。着实用功,便见道无终穷,愈探愈深,必使精白无一毫不彻方可。

    代码中的"坏味道",如"私欲"如"灰尘",每天都在增加,一日不去清除,便会越累越多。如果用功去清除这些"坏味道",不仅能提高自己的编码水平,也能使代码变得"精白无一毫不彻"。这里,整理了日常工作中的一些"坏味道",及清理方法,供大家参考。

     

    让代码性能更高

     

    1.需要 Map 的主键和取值时,应该迭代 entrySet()

    当循环中只需要 Map 的主键时,迭代 keySet() 是正确的。但是,当需要主键和取值时,迭代 entrySet() 才是更高效的做法,比先迭代 keySet() 后再去 get 取值性能更佳。

    反例: 

    Map map = ...;
    for (String key : map.keySet()) {
        String value = map.get(key);
        ...
    }


    正例:

    Map map = ...;
    for (Map.Entry entry : map.entrySet()) {
        String key = entry.getKey();
        String value = entry.getValue();
        ...
    }


    2.应该使用Collection.isEmpty()检测空

    使用 Collection.size() 来检测空逻辑上没有问题,但是使用 Collection.isEmpty()使得代码更易读,并且可以获得更好的性能。任何 Collection.isEmpty() 实现的时间复杂度都是 O(1) ,但是某些 Collection.size() 实现的时间复杂度可能是 O(n) 。

    反例:

    if (collection.size() == 0) {
        ...
    }


    正例:

    if (collection.isEmpty()) {
        ...
    }


    如果需要还需要检测 null ,可采用CollectionUtils.isEmpty(collection)和CollectionUtils.isNotEmpty(collection)。

    3.不要把集合对象传给自己

    此外,由于某些方法要求参数在执行期间保持不变,因此将集合传递给自身可能会导致异常行为。

    反例:

    List list = new ArrayList<>();
    list.add("Hello");
    list.add("World");
    if (list.containsAll(list)) { // 无意义,总是返回true
        ...
    }
    list.removeAll(list); // 性能差, 直接使用clear()


    4.集合初始化尽量指定大小

    Java 的集合类用起来十分方便,但是看源码可知,集合也是有大小限制的。每次扩容的时间复杂度很有可能是 O(n) ,所以尽量指定可预知的集合大小,能减少集合的扩容次数。

    反例:

    int[] arr = new int[]{1, 2, 3};
    List list = new ArrayList<>();
    for (int i : arr) {
        list.add(i);
    }


    正例:

    int[] arr = new int[]{1, 2, 3};
    List list = new ArrayList<>(arr.length);
    for (int i : arr) {
        list.add(i);
    }


    5.字符串拼接使用 StringBuilder 

    一般的字符串拼接在编译期 Java 会进行优化,但是在循环中字符串拼接, Java 编译期无法做到优化,所以需要使用 StringBuilder 进行替换。

    反例:

    String s = "";
    for (int i = 0; i < 10; i++) {
        s += i;
    }


    正例:

    String a = "a";
    String b = "b";
    String c = "c";
    String s = a + b + c; // 没问题,java编译器会进行优化
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < 10; i++) {
        sb.append(i);  // 循环中,java编译器无法进行优化,所以要手动使用StringBuilder
    }


    6.List 的随机访问

    大家都知道数组和链表的区别:数组的随机访问效率更高。当调用方法获取到 List 后,如果想随机访问其中的数据,并不知道该数组内部实现是链表还是数组,怎么办呢?可以判断它是否实现* RandomAccess *接口。

    正例:

    // 调用别人的服务获取到list
    List list = otherService.getList();
    if (list instanceof RandomAccess) {
        // 内部数组实现,可以随机访问
        System.out.println(list.get(list.size() - 1));
    } else {
        // 内部可能是链表实现,随机访问效率低
    }


    7.频繁调用 Collection.contains 方法请使用 Set

    在 Java 集合类库中,List 的 contains 方法普遍时间复杂度是 O(n) ,如果在代码中需要频繁调用 contains 方法查找数据,可以先将 list 转换成 HashSet 实现,将 O(n) 的时间复杂度降为 O(1) 。

    反例: 

    ArrayList list = otherService.getList();
    for (int i = 0; i <= Integer.MAX_VALUE; i++) {
        // 时间复杂度O(n)
        list.contains(i);
    }


    正例:

    ArrayList list = otherService.getList();
    Set set = new HashSet(list);
    for (int i = 0; i <= Integer.MAX_VALUE; i++) {
        // 时间复杂度O(1)
        set.contains(i);
    }


     

    二 让代码更优雅
     

    1.长整型常量后添加大写 L
    在使用长整型常量值时,后面需要添加 L ,必须是大写的 L ,不能是小写的 l ,小写 l 容易跟数字 1 混淆而造成误解。

    反例:

    long value = 1l;
    long max = Math.max(1L, 5);


    正例:

    long value = 1L;
    long max = Math.max(1L, 5L);


    2. 不要使用魔法值

    当你编写一段代码时,使用魔法值可能看起来很明确,但在调试时它们却不显得那么明确了。这就是为什么需要把魔法值定义为可读取常量的原因。但是,-1、0 和 1不被视为魔法值。

    反例: 

    for (int i = 0; i < 100; i++){
        ...
    }
    if (a == 100) {
        ...
    }


    正例:

    private static final int MAX_COUNT = 100;
    for (int i = 0; i < MAX_COUNT; i++){
        ...
    }
    if (count == MAX_COUNT) {
        ...
    }


    3. 不要使用集合实现来赋值静态成员变量

    对于集合类型的静态成员变量,不要使用集合实现来赋值,应该使用静态代码块赋值。

    反例:

    private static Map map = new HashMap() {
        {
            put("a", 1);
            put("b", 2);
        }
    };
     
    private static List list = new ArrayList() {
        {
            add("a");
            add("b");
        }
    };
    
    正例:
    private static Map map = new HashMap<>();
    static {
        map.put("a", 1);
        map.put("b", 2);
    };
     
    private static List list = new ArrayList<>();
    static {
        list.add("a");
        list.add("b");
    };


    4. 建议使用 try-with-resources 语句

    Java 7 中引入了 try-with-resources 语句,该语句能保证将相关资源关闭,优于原来的 try-catch-finally 语句,并且使程序代码更安全更简洁。

    反例:

    private void handle(String fileName) {
        BufferedReader reader = null;
        try {
            String line;
            reader = new BufferedReader(new FileReader(fileName));
            while ((line = reader.readLine()) != null) {
                ...
            }
        } catch (Exception e) {
            ...
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    ...
                }
            }
        }
    }


     

    正例:

    private void handle(String fileName) {
        try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {
            String line;
            while ((line = reader.readLine()) != null) {
                ...
            }
        } catch (Exception e) {
            ...
        }
    }


    5. 删除未使用的私有方法和字段

    删除未使用的私有方法和字段,使代码更简洁更易维护。若有需要再使用,可以从历史提交中找回。

    反例: 

    public class DoubleDemo1 {
        private int unusedField = 100;
        private void unusedMethod() {
            ...
        }
        public int sum(int a, int b) {
            return a + b;
        }
    }


    正例: 

    public class DoubleDemo1 {
        public int sum(int a, int b) {
            return a + b;
        }
    }


    6. 删除未使用的局部变量

    删除未使用的局部变量,使代码更简洁更易维护。

    反例:

    public int sum(int a, int b) {
        int c = 100;
        return a + b;
    }
    正例:

    public int sum(int a, int b) {
        return a + b;
    }
     
    7. 删除未使用的方法参数

    未使用的方法参数具有误导性,删除未使用的方法参数,使代码更简洁更易维护。但是,由于重写方法是基于父类或接口的方法定义,即便有未使用的方法参数,也是不能删除的。

    反例:

    public int sum(int a, int b, int c) {
        return a + b;
    }
    正例:

    public int sum(int a, int b) {
        return a + b;
    }


    8. 删除表达式的多余括号

    对应表达式中的多余括号,有人认为有助于代码阅读,也有人认为完全没有必要。对于一个熟悉 Java 语法的人来说,表达式中的多余括号反而会让代码显得更繁琐。

    反例:

    return (x);
    return (x + 2);
    int x = (y * 3) + 1;
    int m = (n * 4 + 2);
    正例:

    return x;
    return x + 2;
    int x = y * 3 + 1;
    int m = n * 4 + 2;


    9. 工具类应该屏蔽构造函数

    工具类是一堆静态字段和函数的集合,不应该被实例化。但是,Java 为每个没有明确定义构造函数的类添加了一个隐式公有构造函数。所以,为了避免 java "小白"使用有误,应该显式定义私有构造函数来屏蔽这个隐式公有构造函数。

    反例: 

    public class MathUtils {
        public static final double PI = 3.1415926D;
        public static int sum(int a, int b) {
            return a + b;
        }
    }


    正例: 

    public class MathUtils {
        public static final double PI = 3.1415926D;
        private MathUtils() {}
        public static int sum(int a, int b) {
            return a + b;
        }
    }


    10. 删除多余的异常捕获并抛出

    用 catch 语句捕获异常后,什么也不进行处理,就让异常重新抛出,这跟不捕获异常的效果一样,可以删除这块代码或添加别的处理。

    反例:

    private static String readFile(String fileName) throws IOException {
        try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {
            String line;
            StringBuilder builder = new StringBuilder();
            while ((line = reader.readLine()) != null) {
                builder.append(line);
            }
            return builder.toString();
        } catch (Exception e) {
            throw e;
        }
    }


    正例:

    private static String readFile(String fileName) throws IOException {
        try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {
            String line;
            StringBuilder builder = new StringBuilder();
            while ((line = reader.readLine()) != null) {
                builder.append(line);
            }
            return builder.toString();
        }
    }


    11. 公有静态常量应该通过类访问

    虽然通过类的实例访问公有静态常量是允许的,但是容易让人它误认为每个类的实例都有一个公有静态常量。所以,公有静态常量应该直接通过类访问。

    反例:

    public class User {
        public static final String CONST_NAME = "name";
        ...
    }
     
    User user = new User();
    String nameKey = user.CONST_NAME;


    正例:

    public class User {
        public static final String CONST_NAME = "name";
        ...
    }
     
    String nameKey = User.CONST_NAME;


    12. 不要用NullPointerException判断空

    空指针异常应该用代码规避(比如检测不为空),而不是用捕获异常的方式处理。

    反例:

    public String getUserName(User user) {
        try {
            return user.getName();
        } catch (NullPointerException e) {
            return null;
        }
    }


    正例: 

    public String getUserName(User user) {
        if (Objects.isNull(user)) {
            return null;
        }
        return user.getName();
    }


    13. 使用String.valueOf(value)代替""+value

    当要把其它对象或类型转化为字符串时,使用 String.valueOf(value) 比""+value 的效率更高。

    反例:

    int i = 1;
    String s = "" + i;


    正例:

    int i = 1;
    String s = String.valueOf(i);


    14. 过时代码添加 @Deprecated 注解

    当一段代码过时,但为了兼容又无法直接删除,不希望以后有人再使用它时,可以添加 @Deprecated 注解进行标记。在文档注释中添加 @deprecated 来进行解释,并提供可替代方案

    正例:

    /**
     * 保存
     *
     * @deprecated 此方法效率较低,请使用{@link newSave()}方法替换它
     */
    @Deprecated
    public void save(){
        // do something
    }
     

    三 让代码远离 Bug
     

    1. 禁止使用构造方法 BigDecimal(double)


    BigDecimal(double) 存在精度损失风险,在精确计算或值比较的场景中可能会导致业务逻辑异常。

    反例:

    BigDecimal value = new BigDecimal(0.1D); // 0.100000000000000005551115...


    正例:

    BigDecimal value = BigDecimal.valueOf(0.1D);; // 0.1


    2. 返回空数组和空集合而不是 null

    返回 null ,需要调用方强制检测 null ,否则就会抛出空指针异常。返回空数组或空集合,有效地避免了调用方因为未检测 null 而抛出空指针异常,还可以删除调用方检测 null 的语句使代码更简洁。

    反例:

    public static Result[] getResults() {
        return null;
    }
     
    public static List getResultList() {
        return null;
    }
     
    public static Map getResultMap() {
        return null;
    }
     
    public static void main(String[] args) {
        Result[] results = getResults();
        if (results != null) {
            for (Result result : results) {
                ...
            }
        }
     
        List resultList = getResultList();
        if (resultList != null) {
            for (Result result : resultList) {
                ...
            }
        }
     
        Map resultMap = getResultMap();
        if (resultMap != null) {
            for (Map.Entry resultEntry : resultMap) {
                ...
            }
        }
    }


    正例: 

    public static Result[] getResults() {
        return new Result[0];
    }
     
    public static List getResultList() {
        return Collections.emptyList();
    }
     
    public static Map getResultMap() {
        return Collections.emptyMap();
    }
     
    public static void main(String[] args) {
        Result[] results = getResults();
        for (Result result : results) {
            ...
        }
     
        List resultList = getResultList();
        for (Result result : resultList) {
            ...
        }
     
        Map resultMap = getResultMap();
        for (Map.Entry resultEntry : resultMap) {
            ...
        }
    }
    


    3. 优先使用常量或确定值来调用 equals 方法

    对象的 equals 方法容易抛空指针异常,应使用常量或确定有值的对象来调用 equals 方法。当然,使用 java.util.Objects.equals() 方法是最佳实践。

    反例:

    public void isFinished(OrderStatus status) {
        return status.equals(OrderStatus.FINISHED); // 可能抛空指针异常
    }
    正例:

    public void isFinished(OrderStatus status) {
        return OrderStatus.FINISHED.equals(status);
    }
     
    public void isFinished(OrderStatus status) {
        return Objects.equals(status, OrderStatus.FINISHED);
    }


    4. 枚举的属性字段必须是私有不可变

    枚举通常被当做常量使用,如果枚举中存在公共属性字段或设置字段方法,那么这些枚举常量的属性很容易被修改。理想情况下,枚举中的属性字段是私有的,并在私有构造函数中赋值,没有对应的 Setter 方法,最好加上 final 修饰符。

    反例:

    public enum UserStatus {
        DISABLED(0, "禁用"),
        ENABLED(1, "启用");
     
        public int value;
        private String description;
     
        private UserStatus(int value, String description) {
            this.value = value;
            this.description = description;
        }
     
        public String getDescription() {
            return description;
        }
     
        public void setDescription(String description) {
            this.description = description;
        }
    }

     
    正例:

    public enum UserStatus {
        DISABLED(0, "禁用"),
        ENABLED(1, "启用");
     
        private final int value;
        private final String description;
     
        private UserStatus(int value, String description) {
            this.value = value;
            this.description = description;
        }
     
        public int getValue() {
            return value;
        }
     
        public String getDescription() {
            return description;
        }
    }


    5. 小心String.split(String regex)

    字符串 String 的 split 方法,传入的分隔字符串是正则表达式!部分关键字(比如.[]()\| 等)需要转义

    反例:

    "a.ab.abc".split("."); // 结果为[]
    "a|ab|abc".split("|"); // 结果为["a", "|", "a", "b", "|", "a", "b", "c"]


    正例: 

    "a.ab.abc".split("\\."); // 结果为["a", "ab", "abc"]
    "a|ab|abc".split("\\|"); // 结果为["a", "ab", "abc"]


    这篇文章,可以说是从事 Java 开发的经验总结,分享出来以供大家参考。希望能帮大家避免踩坑,让代码更加高效优雅。

    作者简介:王超,花名麟超,阿里巴巴高级地图技术工程师,一直从事Java研发相关工作。Github id: starcwang

    声明:本文系作者投稿,版权归作者所有。
    ————————————————
    版权声明:本文为CSDN博主「CSDN资讯」的原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接及本声明。
    原文链接:https://blog.csdn.net/csdnnews/article/details/100987866

    全文
2019-10-10 14:22:56

    Windows下Nginx+Tomcat整合的安装与配置

    作者:miki分类:[javaEE]浏览(958评论(4

    【转载】Windows下Nginx+Tomcat整合的安装与配置

    原帖:http://zyjustin9.iteye.com/blog/2017394

    相信很多人都听过nginx,这个小巧的东西慢慢地在吞食apache和IIS的份额。那究竟它有什么作用呢?可能很多人未必了解。

    说到反向代理,可能很多人都听说,但具体什么是反向代理,很多人估计就不清楚了。摘一段百度百科上的描述:

    Html代码
    反向代理(Reverse Proxy)方式是指以代理服务器来接受internet上的连接请求,然后将请求转发给内部网络上的服务器,并将从服务器上得到的结果返回给internet上请求连接的客户端,此时代理服务器对外就表现为一个服务器。
    这里讲得很直白。反向代理方式实际上就是一台负责转发的代理 服务器,貌似充当了真正服务器的功能,但实际上并不是,代理服务器只是充当了转发的作用,并且从真正的服务器那里取得返回的数据。这样说,其实nginx 完成的就是这样的工作。我们让nginx监听一个端口,譬如80端口,但实际上我们转发给在8080端口的tomcat,由它来处理真正的请求,当请求完 成后,tomcat返回,但数据此时没直接返回,而是直接给nginx,由nginx进行返回,这里,我们会以为是nginx进行了处理,但实际上进行处 理的是tomcat。

    说到上面的方式,也许很多人又会想起来,这样可以把静态文件交由nginx来进行处理。对,很多用到nginx的地方都是作为静态伺服器,这样可以方便缓存那些静态文件,比如CSS,js,html,htm等文件。

    1)官网地址:http://nginx.org/en/download.html可以到这里去下。

    这里,由于我的是windows,当然下windows版啦。下完后首先要启动吧。进入到nginx文件夹,直接start nginx就OK了。

    比如我下载后放在D:\software \developerTools\server\nginx-1.1.7,直接cmd后cd D:\software\developerTools \server\nginx-1.1.7,有些不习惯命令行的可能会奇怪,它没有进行到那个文件夹。windows并不会在分区间跳转,除非你自己指定 了。所以我们要直接d:如下:

    然后,我们直接start nginx,这里也许你会看到一个窗口一闪而过,根据我们使用tomcat的经验,如果一闪而过,证明有错误了,是吧?但实际上不是。

    此时我们打开任务管理器,可以看到两个nginx.exe在那里好好的。这说明我们已经启动了,至于为什么两个,我们这里不深究。

    现在,我们已经启动了nginx,来看看启动后的nginx是怎样的。直接访问http://localhost可以看到:

    我们可以看到nginx启动成功,现在访问是直接进到nginx的目录里面了。
    

    那么这些实际上是在哪里配置的。这就涉及到nginx的一个重要配置文件nginx.conf了。

    2)我们可以看到nginx文件夹内有一个conf文件夹,其中有好几个文件,其他先不管,我们打开nginx.conf,可以看到一段:

    这段代码在server里面,相当于一个代理服务器,当然可以配置多个。

    下面我们仔细来分析一下:

    listen:表示当前的代理服务器监听的端口,默认的是监听80端口。注意,如果我们配置了多个server,这个listen要配置不一样,不然就不能确定转到哪里去了。

    server_name:表示监听到之后需要转到哪里去,这时我们直接转到本地,这时是直接到nginx文件夹内。

    location:表示匹配的路径,这时配置了/表示所有请求都被匹配到这里

    root:里面配置了root这时表示当匹配这个请求的路径时,将会在这个文件夹内寻找相应的文件,这里对我们之后的静态文件伺服很有用。

    index:当没有指定主页时,默认会选择这个指定的文件,它可以有多个,并按顺序来加载,如果第一个不存在,则找第二个,依此类推。

    下面的error_page是代表错误的页面,这里我们暂时不用,先不管它。

    那我们知道了具体的配置了,怎么让它访问localhost时转到tomcat时。实际上就修改两个地方:

    Java代码

    server_name localhost:8080;  
      
    location / {  
        proxy_pass http://localhost:8080;  
    }  
    

    我们就修改了上面两个地方,我的tomcat在8080端口,可以根据自己的需要修改。这里有一个新元素proxy_pass,它表示代理路径,相当于转发,而不像之前说的root必须指定一个文件夹。

    此时我们修改了文件,是不是就意思着必须先关了nginx再重新启动了,其实不必,nginx可以重新加载文件的。

    我们直接运行:

    Html代码

    nginx -s reload  
    

    如果不想直接加载,而只是想看看自己的配置文件有没有问题,可以直接输入:

    Xml代码

    nginx -t  
    

    这可以检查配置文件中是否有错。 下面我们所有的修改都假设我们修改完成后运行了nginx -s reload
    进行重新加载配置文件,请注意。

    一切没问题了,然后我们再重新打开http://localhost,我们看到下面的页面:

    这时,我们发现它并不是刚才的welcome页面了,而是tomcat的管理页面了,不管我们点击什么链接都是没问题的,相当于直接访问http://localhost:8080一样。

    3)上面我们直接试了一个小例子,让nginx进行转发,即所 谓的反向代理。但实际上我们的需求不会是这样的,我们需要分文件类型来进行过滤,比如jsp直接给tomcat处理,因为nginx并不是servlet 容器,没办法处理JSP,而html,js,css这些不需要处理的,直接给nginx进行缓存。

    下面我们来进行一下配置,让JSP页面直接给tomcat,而html,png等一些图片和JS等直接给nginx进行缓存。

    这时最主要用的还是location这个元素,并且涉及到一部分正则,但不难:

    Xml代码

    location ~ \.jsp$ {  
            proxy_pass http://localhost:8080;  
    }  
    
    location ~ \.(html|js|css|png|gif)$ {  
        root D:/software/developerTools/server/apache-tomcat-7.0.8/webapps/ROOT;  
    }  
    

    我们先要去掉之前配的location /,避免全部请求被拦截了。

    然后我们再来看看http://localhost

    当我们不指定jsp页面的时候,它会出现找不到,因为,此时并没有相应的location匹配,所以就会有404错误,这时就跳到了nginx自定义的error页面去了。

    而当我们用http://localhost/index.jsp去访问时,我们看到了熟悉的页面:

    而且图片那些都显示正常,因为图片是png的,所以直接在tomcat/webapps/ROOT目录下直接查找,当然,如果我们点击Manager Application HOW-TO这个链接,我们发现:

    它还是找不到,为什么呢?因为这是个html页面,但它并不在ROOT目录下,而是在docs目录下,但当我们匹配html时,我们却到ROOT目录下去找,所以还是找不到这个页面。

    一般情况下,如果我们需要用nginx来进行静态文件伺服,一般都会把所有静态文件,html,htm,js,css等都放在同一个文件夹下,这样就不会有tomcat这样的情况了,因为tomcat下的是属于不同的项目,这个我们就没办法了。

    3)有些人会说,这些都只会找一台服务器,但如果我们想在一台服务器挂了的时候,自动去找另外一台,这怎么办?这实际上nginx都考虑到了。

    这时,我们之前用的proxy_pass就有大用途了。

    我们把之前的第一个例子,即全部都代理的修改一下:

    最后修改如下:

    Xml代码  
    upstream local_tomcat {  
        server localhost:8080;  
    }  
      
    server{  
            location / {  
               proxy_pass http://local_tomcat;  
            }  
            #......其他省略  
    }
    

    我们在server外添加了一个upstream,而直接在proxy_pass里面直接用http://+upstream的名称来使用。

    我们还是直接来http://localhost,还是和第一个一样的效果,所有链接都没问题,说明我们配置正确。

    upstream中的server元素必须要注意,不能加http://,但proxy_pass中必须加。

    我们刚才说可以在一个服务器挂了的情况下连到另外一个,那怎么弄呢?

    其实很简单,在upstream中的local_tomcat中配置多一个server。比如我现在弄多一个jetty,端口在9999,所以我们配置如下:

    Xml代码

    upstream local_tomcat {  
        server localhost:8080;  
        server localhost:9999;  
    }  
    

    此时,我们关闭tomcat,而只开jetty。我们来运行http://localhost看看效果:

    我们看到它请求到了jetty的页面,但由于jetty的机制,这时没有显示jetty主页,这个我们先不管。但我们的在一个服务器挂的情况下自动使用另外一个的功能实现了。

    但有时我们就不想它挂的时候访问另外一个,而只是希望一个服务器访问的机会比另外一个大,这个可以在server最后加上一个weight=数字来指定,数字越大,表明请求到的机会越大。

    Xml代码

    upstream local_tomcat {  
        server localhost:8080 weight=1;  
        server localhost:9999 weight=5;  
    }  
    

    这时我们给了jetty一个更高的权值,让它更有机会访问到,实际上当我们刷新http://localhost访问的时候发现jetty访问机率大很多,tomcat几乎没机会访问,一般情况下,如果我们必须这样用,不要相关太大,以免一个服务器负载太大。

    当然,server还有一些其他的元素,比如down表示暂时不用到该服务器等等。这些可以参考nginx的wiki。也许写了一大堆,有人会有问题,那nginx怎么关闭呢?这倒是个问题,其实直接运行nginx -s stop就可以关闭了。

    基本上nginx的用法是这样,深入的以后我们如果用到再学习。

     

    全文
2019-10-09 12:52:29

    测试ckeditor代码高亮显示

    作者:miki分类:[javaEE]浏览(398评论(2
    package jiabin.action;
    
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    import javax.servlet.ServletContext;
    import javax.servlet.ServletContextEvent;
    import javax.servlet.ServletContextListener;
    
    import jiabin.entity.Notice;
    import jiabin.entity.Section;
    import jiabin.entity.Topic;
    import jiabin.entity.Zone;
    import jiabin.service.NoticeService;
    import jiabin.service.SectionService;
    import jiabin.service.TopicService;
    import jiabin.service.ZoneService;
    
    import org.springframework.beans.BeansException;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.ApplicationContextAware;
    import org.springframework.stereotype.Component;
    
    /**date:2017.04.15
     * 功能:由于页面要通过action方法加载从数据库数据,比如帖子列表页面,Topic_list.action
     * 而进入首页的时候,要自动加载论坛空间,版块列表,以及帖子数据,而并没有指定的action跳转,所以要初始化指定action来实现加载
     * 相应数据
     * @author miik
     *
     */
    
    
    
    @Component
    public class InitAction implements ServletContextListener,ApplicationContextAware{
    
    	private static ApplicationContext applicationContext;
    	
    	@Override
    	public void contextDestroyed(ServletContextEvent arg0) {
    		// TODO Auto-generated method stub
    		
    	}
    
    	@Override
    	public void contextInitialized(ServletContextEvent servletContextEvent) {
    		ServletContext application=servletContextEvent.getServletContext();
    	}
    	
    	@Override
    	public void setApplicationContext(ApplicationContext applicationContext)
    			throws BeansException {
    		this.applicationContext=applicationContext;
    	}
    
    
    }
    

     

    全文
2019-10-09 11:35:39