精华内容
下载资源
问答
  • 真正归结为“好公民”(真正了解HTTPClient接口的合同)。EntityUtils.consume将会释放所有由httpEntity所持有的资源,...如果不消耗实体,那么真正取决于finally子句中的“关闭连接管理器”的意思。它会关闭尚未发送...

    真正归结为“好公民”(真正了解HTTPClient接口的合同)。

    EntityUtils.consume将会释放所有由httpEntity所持有的资源,这本质上意味着释放任何底层Stream,并将Connection对象返回到其池中(在连接管理器是多线程的情况下)或释放连接管理器,以便它可以处理下一个请求。

    如果不消耗实体,那么真正取决于finally子句中的“关闭连接管理器”的意思。它会关闭尚未发送回池的待处理流/连接吗?我不知道它会合同做什么(尽管我认为它是实现的)。如果没有,那么您可能会泄漏系统资源(套接字等)。

    发生什么也可能取决于可能(如果它被执行)的Entity对象的可能的完成方法释放其资源,再次,不确定它在实体的合同中这样做。

    让我们假设ConnectionManager在关闭时实际上正确地关闭所有待处理的资源。你还需要消费实体吗?我说是的,因为一个月后,有人会修改你的代码,并在同一个try / finally块中进行第二个HTTP调用,并且可能无法这样做,因为你没有以你应该拥有的方式释放资源(例如,你的客户端是在一个连接池,不释放第一个连接会使第二个调用失败)。

    所以我的观点是:实体是资源,资源在不需要的时候应该被释放。稍后计数别人为你释放可能会在将来伤害你。原作者可能会想到这些。

    作为附注,请注意,您写的实现实际上将消耗读者直到底层流的结尾,所以消费调用实际上根本不会做任何事情,但在我看来,这是一个实现细节(从我的头顶,一旦响应流被完全读取,连接对象将自动释放/发回到http客户端的池中)。还要注意,如果您使用API​​提供的ResponseHandler专业知识,所有这些消费逻辑也将从您抽象出来。最后,API不保证response.getEntity永远不会返回null,所以你应该检查它以避免NullPointerException。

    展开全文
  • java面试宝典

    2013-02-28 16:04:01
    47、在java 中一个类被声明为final 类型,表示了什么意思? 12 48、下面哪些类可以被继承? 12 49、指出下面程序的运行结果: 【基础】 13 52、关于内部类: 13 53、数据类型之间的转换: 14 54、字符串操作:如何实现...
  • Java】JMX MBean

    2020-08-02 20:41:07
    MBean是managed beans的缩写,意思就是被管理Java对象。 JMX中定义了四种MBean,分别是: standard MBeans dynamic MBeans open MBeans model MBeans MBean里封装着受监控对象的数据和操作。 一个完整的MBean...

    一、什么是MBean

    MBean是managed beans的缩写,意思就是被管理的Java对象。
    JMX中定义了四种MBean,分别是:

    • standard MBeans
    • dynamic MBeans
    • open MBeans
    • model MBeans

    MBean里封装着受监控对象的数据和操作。
    一个完整的MBean包含MBean接口及其实现。

    二、示例

    示例为standard MBeans。
    MBean由接口和其实现组成。接口与实现的命名非常严格,接口名必须以MBean结尾。比如接口名为HelloMbean是正确的命名方式,而其实现必须叫Hello。

    接口:xxxMBean
    实现:xxx

    创建HelloMBean:

    public interface HelloMBean {
        void hello();
        String hola();
    }
    

    创建Hello实现HelloMBean:

    public class Hello implements HelloMBean {
        @Override
        public void hello() {
            System.out.println("hello");
        }
    
        @Override
        public String hola() {
            return "hola";
        }
    }
    

    托管MBean:

    
    public class HelloMain {
        public static void main(String[] args) throws Exception{
            // 建立一个MBeanServer,用来管理MBean
            MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
            // 创建AppMBean对象
            Hello mbean = new Hello();
            // 为AppMBean 创建ObjectName实例
            ObjectName name = new ObjectName("com.example.mbeans:type=jmx.Hello");
            // 将AppMbean对象注册到MBeanServer上去
            mbs.registerMBean(mbean, name);
            // Wait forever
            System.out.println("Waiting forever...");
            Thread.sleep(Long.MAX_VALUE);
    
        }
    }
    

    运行main方法;
    然后启动jconsole;
    选择HelloMain ;
    在这里插入图片描述
    点击连接;
    找到Hello;
    在这里插入图片描述
    执行操作,查看变化。
    在这里插入图片描述

    展开全文
  • Java反射之动态代理

    2020-02-21 10:03:30
    这个类的名字(译者注:Proxy意思为代理)就是为什么把动态接口实现叫做动态代理。动态的代理的用途十分广泛,比如数据库连接和事物管理(transaction management)还有单元测试时用到的动态mock对象以及AOP中的方法...

    利用Java反射机制你可以在运行期动态的创建接口的实现。java.lang.reflect.Proxy类就可以实现这一功能。这个类的名字(译者注:Proxy意思为代理)就是为什么把动态接口实现叫做动态代理。动态的代理的用途十分广泛,比如数据库连接和事物管理(transaction management)还有单元测试时用到的动态mock对象以及AOP中的方法拦截功能等等都使用到了动态代理。



    创建代理

    你可以通过使用Proxy.newProxyInstance()方法创建动态代理。newProxyInstance()方法有三个参数:
    1、类加载器(ClassLoader)用来加载动态代理类。
    2、一个要实现的接口的数组。
    3、一个InvocationHandler把所有方法的调用都转到代理上。
    如下例:

    [Java] 纯文本查看 复制代码
    1
    2
    3
    4
    <font style="color:rgb(102, 102, 102)"><font face="Arial, Helvetica, sans-serif">InvocationHandler handler = new MyInvocationHandler();[/font][/color][/p]MyInterface proxy = (MyInterface) Proxy.newProxyInstance(
                                MyInterface.class.getClassLoader(),
                                new Class[] { MyInterface.class },
                                handler);</font></font>

     

    在执行完这段代码之后,变量proxy包含一个MyInterface接口的的动态实现。所有对proxy的调用都被转向到实现了InvocationHandler接口的handler上。有关InvocationHandler的内容会在下一段介绍。

    InvocationHandler接口

    在前面提到了当你调用Proxy.newProxyInstance()方法时,你必须要传入一个InvocationHandler接口的实现。所有对动态代理对象的方法调用都会被转向到InvocationHandler接口的实现上,下面是InvocationHandler接口的定义:

     

    [Java] 纯文本查看 复制代码
    1
    2
    3
    4
    <font style="color:rgb(102, 102, 102)"><font face="Arial, Helvetica, sans-serif">public interface InvocationHandler{
      Object invoke(Object proxy, Method method, Object[] args)
             throws Throwable;
    }</font></font>

     

    下面是它的实现类的定义:

     

    [Java] 纯文本查看 复制代码
    1
    2
    3
    4
    5
    6
    7
    <font style="color:rgb(102, 102, 102)"><font face="Arial, Helvetica, sans-serif">public class MyInvocationHandler implements InvocationHandler{
     
      public Object invoke(Object proxy, Method method, Object[] args)
      throws Throwable {
        //do something "dynamic"
      }
    }</font></font>

     

    传入invoke()方法中的proxy参数是实现要代理接口的动态代理对象。通常你是不需要他的。

    invoke()方法中的Method对象参数代表了被动态代理的接口中要调用的方法,从这个method对象中你可以获取到这个方法名字,方法的参数,参数类型等等信息。关于这部分内容可以查阅之前有关Method的文章。

    Object数组参数包含了被动态代理的方法需要的方法参数。注意:原生数据类型(如int,long等等)方法参数传入等价的包装对象(如Integer, Long等等)。


    常见用例

    动态代理常被应用到以下几种情况中

    • 数据库连接以及事物管理
    • 单元测试中的动态Mock对象
    • 自定义工厂与依赖注入(DI)容器之间的适配器
    • 类似AOP的方法拦截器


    数据库连接以及事物管理

    Spring框架中有一个事物代理可以让你提交/回滚一个事物。在这里我就简短的描述一下,方法调用序列如下:

     

    [Java] 纯文本查看 复制代码
    1
    2
    3
    4
    5
    <font style="color:rgb(102, 102, 102)"><font face="Arial, Helvetica, sans-serif">web controller --> proxy.execute(...);
      proxy --> connection.setAutoCommit(false);
      proxy --> realAction.execute();
        realAction does database work
      proxy --> connection.commit();</font></font>

     

    单元测试中的动态Mock对象

    Butterfly Testing工具通过动态代理来动态实现桩(stub),mock和代理类来进行单元测试。在测试类A的时候如果用到了接口B,你可以传给A一个实现了B接口的mock来代替实际的B接口实现。所有对接口B的方法调用都会被记录,你可以自己来设置B的mock中方法的返回值。
    而且Butterfly Testing工具可以让你在B的mock中包装真实的B接口实现,这样所有调用mock的方法都会被记录,然后把调用转向到真实的B接口实现。这样你就可以检查B中方法真实功能的调用情况。例如:你在测试DAO时你可以把真实的数据库连接包装到mock中。这样的话就与真实的情况一样,DAO可以在数据库中读写数据,mock会把对数据库的读写操作指令都传给数据库,你可以通过mock来检查DAO是不是以正确的方式来使用数据库连接,比如你可以检查是否调用了connection.close()方法。这种情况是不能简单的依靠调用DAO方法的返回值来判断的。

    自定义工厂与依赖注入(DI)容器之间的适配器

    依赖注入容器Butterfly Container有一个非常强大的特性可以让你把整个容器注入到这个容器生成的bean中。但是,如果你不想依赖这个容器的接口,这个容器可以适配你自己定义的工厂接口。你仅仅需要这个接口而不是接口的实现,这样这个工厂接口和你的类看起来就像这样:

     

    [Java] 纯文本查看 复制代码
    1
    2
    3
    4
    5
    <font style="color:rgb(102, 102, 102)"><font face="Arial, Helvetica, sans-serif">public interface IMyFactory {
      Bean   bean1();
      Person person();
      ...
    }</font></font>

     

     

    [Java] 纯文本查看 复制代码
    01
    02
    03
    04
    05
    06
    07
    08
    09
    10
    11
    12
    13
    14
    <font style="color:rgb(102, 102, 102)"><font face="Arial, Helvetica, sans-serif">public class MyAction{
     
      protected IMyFactory myFactory= null;
     
      public MyAction(IMyFactory factory){
        this.myFactory = factory;
      }
     
      public void execute(){
        Bean bean = this.myFactory.bean();
        Person person = this.myFactory.person();
      }
     
    }</font></font>

     

     

    当MyAction类调用通过容器注入到构造方法中的IMyFactory实例的方法时,这个方法调用实际先调用了IContainer.instance()方法,这个方法可以让你从容器中获取实例。这样这个对象可以把Butterfly Container容器在运行期当成一个工厂使用,比起在创建这个类的时候进行注入,这种方式显然更好。而且这种方法没有依赖到Butterfly Container中的任何接口。

    类似AOP的方法拦截器

    Spring框架可以拦截指定bean的方法调用,你只需提供这个bean继承的接口。Spring使用动态代理来包装bean。所有对bean中方法的调用都会被代理拦截。代理可以判断在调用实际方法之前是否需要调用其他方法或者调用其他对象的方法,还可以在bean的方法调用完毕之后再调用其他的代理方法。

    展开全文
  • Java 反射之动态代理

    2016-11-23 19:26:00
    利用Java反射机制你可以在运行期动态的创建接口的实现。...这个类的名字(译者注:Proxy意思为代理)就是为什么把动态接口实现叫做动态代理。动态的代理的用途十分广泛,比如数据库连接和事物管理(transa...

    详见:http://blog.yemou.net/article/query/info/tytfjhfascvhzxcyt205

    利用Java反射机制你可以在运行期动态的创建接口的实现。java.lang.reflect.Proxy类就可以实现这一功能。这个类的名字(译者注:Proxy意思为代理)就是为什么把动态接口实现叫做动态代理。动态的代理的用途十分广泛,比如数据库连接和事物管理(transaction management)还有单元测试时用到的动态mock对象以及AOP中的方法拦截功能等等都使用到了动态代理。


    创建代理你可以通过使用Proxy.newProxyInstance()方法创建动态代理。newProxyInstance()方法有三个参数:
    1、类加载器(ClassLoader)用来加载动态代理类。
    2、一个要实现的接口的数组。
    3、一个InvocationHandler把所有方法的调用都转到代理上。
    如下例:
    1InvocationHandler handler = new MyInvocationHandler();
    2MyInterface proxy = (MyInterface) Proxy.newProxyInstance(
    3                            MyInterface.class.getClassLoader(),
    4                            new Class[] { MyInterface.class },
    5                            handler);
    在执行完这段代码之后,变量proxy包含一个MyInterface接口的的动态实现。所有对proxy的调用都被转向到实现了InvocationHandler接口的handler上。有关InvocationHandler的内容会在下一段介绍。

    InvocationHandler接口在前面提到了当你调用Proxy.newProxyInstance()方法时,你必须要传入一个InvocationHandler接口的实现。所有对动态代理对象的方法调用都会被转向到InvocationHandler接口的实现上,下面是InvocationHandler接口的定义:
    1public interface InvocationHandler{
    2  Object invoke(Object proxy, Method method, Object[] args)
    3         throws Throwable;
    4}
    下面是它的实现类的定义:
    1public class MyInvocationHandler implements InvocationHandler{
    2
    3  public Object invoke(Object proxy, Method method, Object[] args)
    4  throws Throwable {
    5    //do something "dynamic"
    6  }
    7}
    传入invoke()方法中的proxy参数是实现要代理接口的动态代理对象。通常你是不需要他的。
    invoke()方法中的Method对象参数代表了被动态代理的接口中要调用的方法,从这个method对象中你可以获取到这个方法名字,方法的参数,参数类型等等信息。关于这部分内容可以查阅之前有关Method的文章。
    Object数组参数包含了被动态代理的方法需要的方法参数。注意:原生数据类型(如int,long等等)方法参数传入等价的包装对象(如Integer, Long等等)。

    常见用例动态代理常被应用到以下几种情况中

         * 数据库连接以及事物管理
         * 单元测试中的动态Mock对象
         * 自定义工厂与依赖注入(DI)容器之间的适配器
         * 类似AOP的方法拦截器


    数据库连接以及事物管理Spring框架中有一个事物代理可以让你提交/回滚一个事物。它的具体原理在 Advanced Connection and Transaction Demarcation and Propagation一文中有详细描述,所以在这里我就简短的描述一下,方法调用序列如下:
    1web controller --> proxy.execute(...);
    2  proxy --> connection.setAutoCommit(false);
    3  proxy --> realAction.execute();
    4    realAction does database work
    5  proxy --> connection.commit();

    单元测试中的动态Mock对象Butterfly Testing工具通过动态代理来动态实现桩(stub),mock和代理类来进行单元测试。在测试类A的时候如果用到了接口B,你可以传给A一个实现了B接口的mock来代替实际的B接口实现。所有对接口B的方法调用都会被记录,你可以自己来设置B的mock中方法的返回值。
    而且Butterfly Testing工具可以让你在B的mock中包装真实的B接口实现,这样所有调用mock的方法都会被记录,然后把调用转向到真实的B接口实现。这样你就可以检查B中方法真实功能的调用情况。例如:你在测试DAO时你可以把真实的数据库连接包装到mock中。这样的话就与真实的情况一样,DAO可以在数据库中读写数据,mock会把对数据库的读写操作指令都传给数据库,你可以通过mock来检查DAO是不是以正确的方式来使用数据库连接,比如你可以检查是否调用了connection.close()方法。这种情况是不能简单的依靠调用DAO方法的返回值来判断的。

    自定义工厂与依赖注入(DI)容器之间的适配器依赖注入容器Butterfly Container有一个非常强大的特性可以让你把整个容器注入到这个容器生成的bean中。但是,如果你不想依赖这个容器的接口,这个容器可以适配你自己定义的工厂接口。你仅仅需要这个接口而不是接口的实现,这样这个工厂接口和你的类看起来就像这样:
    1public interface IMyFactory {
    2  Bean   bean1();
    3  Person person();
    4  ...
    5}

    01public class MyAction{
    02
    03  protected IMyFactory myFactory= null;
    04
    05  public MyAction(IMyFactory factory){
    06    this.myFactory = factory;
    07  }
    08
    09  public void execute(){
    10    Bean bean = this.myFactory.bean();
    11    Person person = this.myFactory.person();
    12  }
    13
    14}
    当MyAction类调用通过容器注入到构造方法中的IMyFactory实例的方法时,这个方法调用实际先调用了IContainer.instance()方法,这个方法可以让你从容器中获取实例。这样这个对象可以把Butterfly Container容器在运行期当成一个工厂使用,比起在创建这个类的时候进行注入,这种方式显然更好。而且这种方法没有依赖到Butterfly Container中的任何接口。

    类似AOP的方法拦截器Spring框架可以拦截指定bean的方法调用,你只需提供这个bean继承的接口。Spring使用动态代理来包装bean。所有对bean中方法的调用都会被代理拦截。代理可以判断在调用实际方法之前是否需要调用其他方法或者调用其他对象的方法,还可以在bean的方法调用完毕之后再调用其他的代理方法。

    展开全文
  • java 面试题 总结

    2009-09-16 08:45:34
     GC是垃圾收集的意思(Gabage Collection),内存处理是编程人员容易出现问题的地方,忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃,Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收...
  • java面试宝典2012

    2012-12-16 20:43:41
    18、Spring 的依赖注入是什么意思? 给一个 Bean 的 message 属性, 字符串类型, 注入值为 "Hello" 的 XML 配置文件该怎么写? 137 19、Jdo是什么? 137 20、什么是spring的IOC AOP 137 21、STRUTS的工作流程! 137 22、...
  • JAVA面试宝典2010

    2011-12-20 16:13:24
    18、Spring 的依赖注入是什么意思? 给一个 Bean 的 message 属性, 字符串类型, 注入值为 "Hello" 的 XML 配置文件该怎么写? 125 19、Jdo是什么? 125 20、什么是spring的IOC AOP 126 21、STRUTS的工作流程! 126 22、...
  • JAVA面试题集合面试技能大全 JAVA面试题集 基础知识: 1.C++或Java中的异常处理机制的简单原理和应用。 当JAVA程序违反了JAVA的语义...7. 在java中一个类被声明为final类型,表示了什么意思? ……………………
  • JAVA面试题最全集

    2010-03-13 13:09:10
    87.UNIX中QT是什么意思? 88.在软件开发生命周期中的哪个阶段开始测试? 89.dotnet与J2EE的比较? 90.什么是ActiveX? 91.Java中IDL是什么? 92.ISO9000和CMM是什么?IS09000和CMM(软件能力成熟度模型)认证是国际上...
  • Java面试宝典-经典

    2015-03-28 21:44:36
    18、Spring 的依赖注入是什么意思? 给一个 Bean 的 message 属性, 字符串类型, 注入值为 "Hello" 的 XML 配置文件该怎么写? 125 19、Jdo是什么? 125 20、什么是spring的IOC AOP 126 21、STRUTS的工作流程! 126 22、...
  • Java 面试宝典

    2013-02-01 10:02:08
    23、java 中实现多态的机制是什么? ......................................................................... 17 24、abstract class 和 interface 有什么区别? ...............................................
  • 最新Java面试宝典pdf版

    热门讨论 2011-08-31 11:29:22
    18、Spring 的依赖注入是什么意思? 给一个 Bean 的 message 属性, 字符串类型, 注入值为 "Hello" 的 XML 配置文件该怎么写? 125 19、Jdo是什么? 125 20、什么是spring的IOC AOP 126 21、STRUTS的工作流程! 126 22、...
  • Java面试宝典2012版

    2012-12-03 21:57:42
    18、Spring 的依赖注入是什么意思? 给一个 Bean 的 message 属性, 字符串类型, 注入值为 "Hello" 的 XML 配置文件该怎么写? 125 19、Jdo是什么? 125 20、什么是spring的IOC AOP 126 21、STRUTS的工作流程! 126 ...
  • java基础-集合-List

    2019-10-21 17:30:07
    什么是List 初识 list字面翻译是列表、清单的意思。List是一种有序的容器,通过线性方式管理数据,它的内部结构是双向链表; 在jdk中是属于集合类工具,继承了collection接口。 简单看一下List接口的方法 相知 ...
  • Java面试宝典2012新版

    2012-06-26 19:20:00
    18、Spring 的依赖注入是什么意思? 给一个 Bean 的 message 属性, 字符串类型, 注入值为 "Hello" 的 XML 配置文件该怎么写? 125 19、Jdo是什么? 125 20、什么是spring的IOC AOP 126 21、STRUTS的工作流程! 126 22、...
  • Java面试笔试资料大全

    热门讨论 2011-07-22 14:33:56
    18、Spring 的依赖注入是什么意思? 给一个 Bean 的 message 属性, 字符串类型, 注入值为 "Hello" 的 XML 配置文件该怎么写? 125 19、Jdo是什么? 125 20、什么是spring的IOC AOP 126 21、STRUTS的工作流程! 126 22、...
  • 这个类的名字(译者注:Proxy意思为代理)就是为什么把动态接口实现叫做动态代理。动态的代理的用途十分广泛,比如数据库连接和事物管理(transaction management)还有单元测试时用到的动态mock对象以及AOP中的方法...
  • Java面试宝典2010版

    2011-06-27 09:48:27
    18、Spring 的依赖注入是什么意思? 给一个 Bean 的 message 属性, 字符串类型, 注入值为 "Hello" 的 XML 配置文件该怎么写? 19、Jdo是什么? 20、什么是spring的IOC AOP 21、STRUTS的工作流程! 22、spring 与EJB...
  • java 常用设计模式chm

    2010-12-11 00:29:56
    Proxy是比较有用途的一种模式,而且变种较多,应用场合覆盖从小结构到整个系统的大结构,Proxy是代理的意思,我们也许有代理服务器等概念,代理概念可以解释为:在出发点到目的地之间有一道中间层,意为代理. 设计模式中...
  • 18、Spring 的依赖注入是什么意思? 给一个 Bean 的 message 属性, 字符串类型, 注入值为 "Hello" 的 XML 配置文件该怎么写? 125 19、Jdo是什么? 125 20、什么是spring的IOC AOP 126 21、STRUTS的工作流程! 126 22、...
  •  GC是垃圾收集的意思(Gabage Collection),内存处理是编程人员容易出现问题的地方,忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃,Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收...
  • 一、BeanFactory基本认识: 该接口提供了高级IOC配置机制,实现对不同类型JAVA对象的统一管理,从字面意思来理解意思是Bean工厂,即用来创建Bean的工厂,这里的Bean和我们之前理解的JavaBean有些不同,...
  • 18、Spring 的依赖注入是什么意思? 给一个 Bean 的 message 属性, 字符串类型, 注入值为 "Hello" 的 XML 配置文件该怎么写? 125 19、Jdo是什么? 125 20、什么是spring的IOC AOP 126 21、STRUTS的工作流程! 126 22、...
  • JAVA基础课程 第二十一天 泛型 为什么要有泛型 ①泛型设计的背景 ​ 泛型既标签的意思~ ​ 集合容器在设计阶段/声明阶段不能确定这个容器到底实际存的是声明类型的对象,所以在JDK1.5之前元素都设计为Object,JDK...

空空如也

空空如也

1 2 3 4
收藏数 74
精华内容 29
关键字:

java接口管理什么意思

java 订阅