精华内容
下载资源
问答
  • 关于对数据源的请教我看了一些介绍jdbc连接oracle数据库的文章....使用数据源连接数据库  使用驱动类包连接数据库 相比有什么优缺点?2.若使用jdbc-odbc桥进行数据库的连接,就必需数据源来连接吗?什么

    愤怒 关于对数据源的请教

    我看了一些介绍用jdbc连接oracle数据库的文章.其中一部分是介绍使用数据源来连接的(也就是先在win2000系统的控制面版中的odbc设置数据源),但有些文章是没有使用数据源去直接连接oracle数据库的...

    1.使用数据源连接数据库  和  使用驱动类包连接数据库  相比有什么优缺点?
    2.若使用jdbc-odbc桥进行数据库的连接,就必需用数据源来连接吗?什么情况下使用数据源连接?

    3.若直接使用jdbc,而不是使用jdbc-odbc桥进行连接.需要先设置数据源吗?

    4.举个简单明了的例子:某个数据源名(dsname)是不是相当于oracle数据库url中的这个大概字段(@hostname吐舌ort:sid)?

    5.数据源的好处和作用是什么 

    展开全文
  • jaxrpc.jar Axis运行所需要的组件 saaj.jar 创建到端点的点到点连接的方法、创建并处理SOAP消息附件的方法,以及接收处理SOAP错误的方法. wsdl4j-1.5.1.jar Axis运行所需要的组件 activation.jar JAF框架的...

    axis.jar SOAP引擎包
    commons-discovery-0.2.jar 用来发现、查找和实现可插入式接口,提供一些一般类实例化、单件的生命周期管理的常用方法.
    jaxrpc.jar Axis运行所需要的组件包 saaj.jar 创建到端点的点到点连接的方法、创建并处理SOAP消息和附件的方法,以及接收和处理SOAP错误的方法.
    wsdl4j-1.5.1.jar Axis运行所需要的组件包
    activation.jar JAF框架的jar包
    annotations-api.jar 使用注解所需jar
    ant.jar 用于自动化调用程序完成项目的编译,打包,测试等
    aopalliance-1.0.jar 支持Spring AOP
    asm-2.2.3.jar ASM字节码库
    asm-commons-2.2.3.jar ASM字节码库
    asm-util-2.2.3.jar Java字节码操纵和分析框架
    aspectjrt.jar 处理事务和AOP所需的包
    aspectjweaver.jar 处理事务和AOP所需的包
    axiom-api-1.2.7.jar Axis 对象模型
    axiom-impl-1.2.7.jar Axis 对象模型
    bcprov-jdk15-140.jar 基于java1.5 的加密算法实现
    bfmclientmodel.jar 使用WebSphere所需jar包
    bpcclientcore.jar 使用WebSphere所需jar包
    bpe137650.jar 提供远程访问BPE容器的实现。
    bsh-2.0b4.jar 解决负载逻辑运算
    c3p0-0.9.0.jar 开放源代码的JDBC连接池
    cglib-nodep-2.1_3.jar Spring中自动代理所需jar包
    cobertura.jar 测量测试覆盖率
    commons-beanutils-1.7.0.jar 动态的获取/设值Java Bean的属性
    commons-chain-1.1.jar 实现责任链设计模式的Java 类库
    commons-codec-1.3.jar 用来处理常用的编码方法的工具类包,例如DES、SHA1、MD5、Base64等等
    commons-collections-3.1.jar 对标准java Collection的扩展
    commons-collections.jar 对标准java Collection的扩展
    commons-digester-1.8.jar 用于处理struts-config.xml配置文件
    commons-fileupload-1.1.1.jar struts上传文件
    commons-httpclient-3.1.jar 用来简化HTTP客户端与服务器端进行各种通信编程实现
    commons-io-1.1.jar 针对java.io.InputStream和Reader进行了扩展
    commons-lang-2.4.jar 对java.lang.*的扩展
    commons-logging-1.1.1.jar 日志包
    commons-pool-1.3.jar 实现对象池化框架
    commons-validator-1.3.1.jar 用来把验证规则程序提取出来,以供重复使用
    db2jcc.jar java连接DB2所需jar
    db2jcc_license_cu.jar java连接DB2所需jar
    dom4j-1.6.1.jar 解析XML
    ehcache-1.2.4.jar hibernate的二级缓存如果用ehcache的时候需要此jar包
    emf.jar 基于Eclipse的模型框架
    ezmorph-1.0.6.jar 使用JSON所需的jar包
    FastInfoset-1.2.2.jar 使用WebService所需的jar包
    freemarker-2.3.8.jar Strus2支持的一种表现层框架
    geronimo-activation_1.1_spec-1.0.2.jar Apache Geronimo所带jar包,
    geronimo-annotation_1.0_spec-1.1.1.jar Apache Geronimo所带jar包
    geronimo-javamail_1.4_spec-1.3.jar Apache Geronimo所带jar包
    geronimo-jaxws_2.1_spec-1.0.jar Apache Geronimo所带jar包
    geronimo-jms_1.1_spec-1.1.1.jar Apache Geronimo所带jar包
    geronimo-servlet_2.5_spec-1.2.jar Apache Geronimo所带jar包
    geronimo-stax-api_1.0_spec-1.0.1.jar Apache Geronimo所带jar包
    hibernate3.jar Hibernate3的核心jar包
    htmclientmodel.jar 使用WebSphere所需jar包
    jakarta-oro.jar 一套文本处理工具,提供per15.0兼容的表达式,AWK-like表达式,Glob表达式。
    javassist.jar Javassist 字节码解释器
    jaxb-api-2.1.jar 使用WebService所需的jar包
    jaxb-impl-2.1.7.jar 使用CXF所需jar包
    jaxb-xjc-2.1.7.jar 使用CXF所需jar包
    jaxen-1.1.1.jar 解析XML
    jcifs-1.2.22.jar 实现单点登陆
    jdom2-1.0.jar 解析XML
    jdom-1.0.jar 解析XML
    jettison-1.0.1.jar 使用CXF所需jar包
    jetty-6.1.9.jar Jetty Http服务器jar
    jetty-util-6.1.9.jar Jetty Http服务器jar
    jra-1.0-alpha-4.jar 使用CXF所需jar包
    js-1.6R7.jar 使用CXF所需jar包
    json-lib-2.2.3-jdk13.jar 使用JSON所需的jar包
    jsonplugin-0.25.jar strus2的JSON插件
    jsr311-api-0.8.jar 使用CXF所需jar包
    jstl.jar JSTL标签库
    jta.jar 标准的 JAVA 事务处理接口
    junit.jar 用于单元测试
    jxl.jar 通过java操作excel表格的工具类库
    ldap.jar JNDI目录服务和LDAO服务器所需的jar
    ldapbp.jar JNDI目录服务和LDAO服务器所需的jar
    log4j-1.2.15.jar 提供日志功能
    mail.jar java发送邮件jar包
    neethi-2.0.4.jar 使用CXF所需jar包
    odmg-3.0.jar ODMG是一个ORM的规范,Hibernate实现了ODMG规范,这是一个核心的库
    ognl-2.6.11.jar struts2中OGNL语言
    ojdbc14.jar Oracle数据库驱动包
    opensaml-1.1.jar 使用CXF所需jar包
    oro-2.0.8.jar Validator框架所需的jar包
    oscache-2.1.jar Java 对象的缓存工具
    poi-3.1-FINAL-20080629.jar 操作exce所需jar包
    poi-contrib-3.1-FINAL-20080629.jar 操作exce所需jar包
    poi-ooxml-3.6-20091214.jar 提供对office的word、excel、visio及ppt的操作
    poi-ooxml-schemas-3.6-20091214.jar 提供对office的word、excel、visio及ppt的操作
    poi-scratchpad-3.1-FINAL-20080629.jar 提供对office的word、excel、visio及ppt的操作
    processCommon.jar IBM WebSphere 运行所需jar
    ProcessCommonLibrary.jar IBM WebSphere 运行所需jar
    processIdentity.jar IBM WebSphere 运行所需jar
    ProcessInformation.jar 进程监视软件包
    proxool-0.9.1.jar 数据库连接池
    proxool-cglib.jar 数据库连接池
    quartz-1.6.0.jar 开源作业调度框架
    saaj-api-1.3.jar 使用axis所需的jar
    saaj-impl-1.3.2.jar 使用axis所需的jar
    serializer-2.7.1.jar XML序列化
    slf4j-jdk14-1.5.6.jar 整合各种日志框架的工具
    spring208.jar spring核心框架
    spring-ldap-1.2-RC1.jar spring下LDAP
    spring-mock.jar spring的测试框架
    standard.jar 使用JSTL标签库所需的jar
    stax-api-1.0.1.jar 解析XML
    struts2-core-2.0.14.jar struts2核心jar
    struts2-spring-plugin-2.0.6.jar struts2整合Spring所需jar
    taglibs-datetime.jar Apache开源组织提供标签库,用于格式化日期。
    taglibs-mailer.jar 用于发送邮件
    taglibs-string.jar Apache开源组织提供标签库,用于对String的操作。
    task137650.jar Portal技术在SOA系统集成应用中实现所需的jar
    utility.jar Apache开源组织提供标签库
    velocity-1.5.jar 一个免费的开源模板框架
    wsdl4j-1.6.2.jar 用来解析服务的WSDl文件
    wss4j-1.5.4.jar 创建CXF所需jar
    wstx-asl-3.2.6.jar 创建CXF所需jar
    xbean-spring-2.8.jar 使用xfire所需jar
    xerces-2.6.2.jar XML解析器
    xfire-all-1.2.6.jar 用于实现WebService
    XmlSchema-1.1.jar 使用xfire所需jar
    xwork-2.0.7.jar WebWork核心jar

    jar包 用途
    axis.jar SOAP引擎包
    commons-discovery-0.2.jar 用来发现、查找和实现可插入式接口,提供一些一般类实例化、单件的生命周期管理的常用方法.
    jaxrpc.jar Axis运行所需要的组件包
    saaj.jar 创建到端点的点到点连接的方法、创建并处理SOAP消息和附件的方法,以及接收和处理SOAP错误的方法.
    wsdl4j-1.5.1.jar Axis运行所需要的组件包
    activation.jar JAF框架的jar包
    annotations-api.jar 使用注解所需
    jar ant.jar 用于自动化调用程序完成项目的编译,打包,测试等
    aopalliance-1.0.jar 支持Spring AOP
    asm-2.2.3.jar ASM字节码库
    asm-commons-2.2.3.jar ASM字节码库
    asm-util-2.2.3.jar Java字节码操纵和分析框架
    aspectjrt.jar 处理事务和AOP所需的包
    aspectjweaver.jar 处理事务和AOP所需的包
    axiom-api-1.2.7.jar Axis 对象模型
    axiom-impl-1.2.7.jar Axis 对象模型
    bcprov-jdk15-140.jar 基于java1.5 的加密算法实现
    bfmclientmodel.jar 使用WebSphere所需jar包
    bpcclientcore.jar 使用WebSphere所需jar包
    bpe137650.jar 提供远程访问BPE容器的实现。
    bsh-2.0b4.jar 解决负载逻辑运算
    c3p0-0.9.0.jar 开放源代码的JDBC连接池
    cglib-nodep-2.1_3.jar Spring中自动代理所需jar包
    cobertura.jar 测量测试覆盖率
    commons-beanutils-1.7.0.jar 动态的获取/设值Java Bean的属性
    commons-chain-1.1.jar 实现责任链设计模式的Java 类库
    commons-codec-1.3.jar 用来处理常用的编码方法的工具类包,例如DES、SHA1、MD5、Base64等等
    commons-collections-3.1.jar 对标准java Collection的扩展
    commons-collections.jar 对标准java Collection的扩展
    commons-digester-1.8.jar 用于处理struts-config.xml配置文件
    commons-fileupload-1.1.1.jar struts上传文件
    commons-httpclient-3.1.jar 用来简化HTTP客户端与服务器端进行各种通信编程实现
    commons-io-1.1.jar 针对java.io.InputStream和Reader进行了扩展
    commons-lang-2.4.jar 对java.lang.*的扩展
    commons-logging-1.1.1.jar 日志包
    commons-pool-1.3.jar 实现对象池化框架
    commons-validator-1.3.1.jar 用来把验证规则程序提取出来,以供重复使用
    db2jcc.jar java连接DB2所需jar
    db2jcc_license_cu.jar java连接DB2所需jar
    dom4j-1.6.1.jar 解析XML
    ehcache-1.2.4.jar hibernate的二级缓存如果用ehcache的时候需要此jar包
    emf.jar 基于Eclipse的模型框架
    ezmorph-1.0.6.jar 使用JSON所需的jar包
    FastInfoset-1.2.2.jar 使用WebService所需的jar包
    freemarker-2.3.8.jar Strus2支持的一种表现层框架
    geronimo-activation_1.1_spec-1.0.2.jar Apache Geronimo所带jar包,
    geronimo-annotation_1.0_spec-1.1.1.jar Apache Geronimo所带jar包
    geronimo-javamail_1.4_spec-1.3.jar Apache Geronimo所带jar包
    geronimo-jaxws_2.1_spec-1.0.jar Apache Geronimo所带jar包
    geronimo-jms_1.1_spec-1.1.1.jar Apache Geronimo所带jar包
    geronimo-servlet_2.5_spec-1.2.jar Apache Geronimo所带jar包
    geronimo-stax-api_1.0_spec-1.0.1.jar Apache Geronimo所带jar包
    hibernate3.jar Hibernate3的核心jar包
    htmclientmodel.jar 使用WebSphere所需jar包
    jakarta-oro.jar 一套文本处理工具,提供per15.0兼容的表达式,AWK-like表达式,Glob表达式。
    javassist.jar Javassist 字节码解释器
    jaxb-api-2.1.jar 使用WebService所需的jar包
    jaxb-impl-2.1.7.jar 使用CXF所需jar包
    jaxb-xjc-2.1.7.jar 使用CXF所需jar包
    jaxen-1.1.1.jar 解析XML
    jcifs-1.2.22.jar 实现单点登陆
    jdom2-1.0.jar 解析XML
    jdom-1.0.jar 解析XML
    jettison-1.0.1.jar 使用CXF所需jar包
    jetty-6.1.9.jar Jetty Http服务器jar
    jetty-util-6.1.9.jar Jetty Http服务器jar
    jra-1.0-alpha-4.jar 使用CXF所需jar包
    js-1.6R7.jar 使用CXF所需jar包
    json-lib-2.2.3-jdk13.jar 使用JSON所需的jar包
    jsonplugin-0.25.jar strus2的JSON插件
    jsr311-api-0.8.jar 使用CXF所需jar包
    jstl.jar JSTL标签库
    jta.jar 标准的 JAVA 事务处理接口
    junit.jar 用于单元测试
    jxl.jar 通过java操作excel表格的工具类库
    ldap.jar JNDI目录服务和LDAO服务器所需的jar
    ldapbp.jar JNDI目录服务和LDAO服务器所需的jar
    log4j-1.2.15.jar 提供日志功能
    mail.jar java发送邮件jar包
    neethi-2.0.4.jar 使用CXF所需jar包
    odmg-3.0.jar ODMG是一个ORM的规范,Hibernate实现了ODMG规范,这是一个核心的库
    ognl-2.6.11.jar struts2中OGNL语言
    ojdbc14.jar Oracle数据库驱动包
    opensaml-1.1.jar 使用CXF所需jar包
    oro-2.0.8.jar Validator框架所需的jar包
    oscache-2.1.jar Java 对象的缓存工具
    poi-3.1-FINAL-20080629.jar 操作exce所需jar包
    poi-contrib-3.1-FINAL-20080629.jar 操作exce所需jar包
    poi-ooxml-3.6-20091214.jar 提供对office的word、excel、visio及ppt的操作
    poi-ooxml-schemas-3.6-20091214.jar 提供对office的word、excel、visio及ppt的操作
    poi-scratchpad-3.1-FINAL-20080629.jar 提供对office的word、excel、visio及ppt的操作
    processCommon.jar IBM WebSphere 运行所需jar
    ProcessCommonLibrary.jar IBM WebSphere 运行所需jar
    processIdentity.jar IBM WebSphere 运行所需jar
    ProcessInformation.jar 进程监视软件包
    proxool-0.9.1.jar 数据库连接池
    proxool-cglib.jar 数据库连接池
    quartz-1.6.0.jar 开源作业调度框架
    saaj-api-1.3.jar 使用axis所需的jar
    saaj-impl-1.3.2.jar 使用axis所需的jar
    serializer-2.7.1.jar XML序列化
    slf4j-jdk14-1.5.6.jar 整合各种日志框架的工具
    spring208.jar spring核心框架
    spring-ldap-1.2-RC1.jar spring下LDAP
    spring-mock.jar spring的测试框架
    standard.jar 使用JSTL标签库所需的jar
    stax-api-1.0.1.jar 解析XML
    struts2-core-2.0.14.jar struts2核心jar
    struts2-spring-plugin-2.0.6.jar struts2整合Spring所需jar
    taglibs-datetime.jar Apache开源组织提供标签库,用于格式化日期。
    taglibs-mailer.jar 用于发送邮件
    taglibs-string.jar Apache开源组织提供标签库,用于对String的操作。
    task137650.jar Portal技术在SOA系统集成应用中实现所需的jar
    utility.jar Apache开源组织提供标签库
    velocity-1.5.jar 一个免费的开源模板框架
    wsdl4j-1.6.2.jar 用来解析服务的WSDl文件
    wss4j-1.5.4.jar 创建CXF所需jar
    wstx-asl-3.2.6.jar 创建CXF所需jar
    xbean-spring-2.8.jar 使用xfire所需jar
    xerces-2.6.2.jar XML解析器
    xfire-all-1.2.6.jar 用于实现WebService
    XmlSchema-1.1.jar 使用xfire所需jar
    xwork-2.0.7.jar WebWork核心jar

    展开全文
  • 文章目录前言的生命周期加载验证准备解析初始化案例一案例二案例三案例四类加载器加载器双亲委派模型破坏双亲委派模型第一次SPITomcatOSGI总结前言前面学习了虚拟机的内存结构、对象的分配创建,但对象所...

    0bd8f6536de67ad2b3958f6b4afdd6f4.png

    文章目录

    • 前言
    • 类的生命周期
      • 加载
      • 验证
      • 准备
      • 解析
      • 初始化
        • 案例一
        • 案例二
        • 案例三
        • 案例四
    • 类加载器
      • 类加载器和双亲委派模型
      • 破坏双亲委派模型
        • 第一次
        • SPI
        • Tomcat
        • OSGI
    • 总结

    前言

    前面学习了虚拟机的内存结构、对象的分配和创建,但对象所对应的类是怎么加载到虚拟机中来的呢?加载过程中需要做些什么?什么是双亲委派机制以及为什么要打破双亲委派机制?

    类的生命周期

    758b20e1182b42aff24316ad8c279e90.png


    类的生命周期包含了如上的7个阶段,其中验证准备解析统称为连接 ,类的加载主要是前五个阶段,每个阶段基本上保持如上顺序开始(仅仅是开始,实际上执行是交叉混合的),只有解析阶段不一定,在初始化后也有可能才开始执行解析,这是为了支持动态语言。

    加载

    加载就是将字节码的二进制流转化为方法区的运行时数据结构,并生成类所对象的Class对象,字节码二进制流可以是我们编译后的class文件,也可以从网络中获取,或者运行时动态生成(动态代理)等等。
    那什么时候会触发类加载呢?这个在虚拟机规范中没有明确定义,只是规定了何时需要执行初始化(稍后详细分析)。

    验证

    这个阶段很好理解,就是进行必要的校验,确保加载到内存中的字节码是符合要求的,主要包含以下四个校验步骤(了解即可):

    • 文件格式校验:这个阶段要校验的东西非常多,主要的有下面这些(实际上远远不止)
      • 是否以魔数0xCAFEBABE开头。
      • 主、次版本号是否在当前Java虚拟机接受范围之内。
      • 常量池的常量中是否有不被支持的常量类型(检查常量tag标志)。
      • 指向常量的各种索引值中是否有指向不存在的常量或不符合类型的常量。
      • CONSTANT_Utf8_info型的常量中是否有不符合UTF-8编码的数据。
      • Class文件中各个部分及文件本身是否有被删除的或附加的其他信息。
      • 。。。。。。
    • 元数据校验:对字节码描述信息进行语义分析。
      • 这个类是否有父类(除了java.lang.Object之外,所有的类都应当有父类)。
      • 这个类的父类是否继承了不允许被继承的类(被final修饰的类)。
      • 如果这个类不是抽象类,是否实现了其父类或接口之中要求实现的所有方法。
      • 类中的字段、方法是否与父类产生矛盾(例如覆盖了父类的final字段,或者出现不符合规则的方法重载,例如方法参数都一致,但返回值类型却不同等)。
      • 。。。。。。
    • 字节码校验:确保程序没有语法和逻辑错误,这是整个验证阶段最复杂的一个步骤。
      • 保证任意时刻操作数栈的数据类型与指令代码序列都能配合工作,例如不会出现类似于“在操作栈放置了一个 int 类型的数据,使用时却按 long 类型来加载入本地变量表中”这样的情况。
      • 保证任何跳转指令都不会跳转到方法体以外的字节码指令上。
      • 保证方法体中的类型转换总是有效的,例如可以把-个子类对象赋值给父类数据类型,这是安全的,但是把父类对象赋值给子类数据类型,甚至把对象赋值给与它毫无继承关系、完全不相干的一个数据类型,则是危险和不合法的。
      • 。。。。。。
    • 符号引用验证:这个阶段发生在符号引用转为直接引用的时候,即实际上是在解析阶段中进行的。
      • 符号引用中通过字符串描述的全限定名是否能找到对应的类。
      • 在指定类中是否存在符合方法的字段描述符及简单名称所描述的方法和字段。
      • 符号引用中的类、字段、方法的可访问性( private、 protected. public、 )。
      • 是否可被当前类访问。
      • 。。。。。。

    准备

    该阶段是为类变量(static)分配内存并设置零值,即类只要经过准备阶段其中的静态变量就是可使用的了,但此时类变量的值还不是我们想要的值,需要经过初始化阶段才会将我们希望的值赋值给对应的静态变量。

    解析

    解析就是将常量池中的符号引用替换为直接引用的过程。符号引用就是一个代号,比如我们的名字,而这里可以理解为就是类的完全限定名直接引用则是对应的具体的人、物,这里就是指目标的内存地址。为什么需要符号引用呢?因为类在加载到内存之前还没有分配内存地址,因此必然需要一个东西指代它。这个阶段包含了类或接口的解析字段解析类方法解析接口方法解析,在解析的过程中可能会抛出以下异常:

    • java.lang.NoSuchFieldError:找不到字段
    • java.lang.IllegalAccessError:不具有访问权限
    • java.lang.NoSuchMethodError:找不到方法

    初始化

    这是类加载过程中的最后一个步骤,主要是收集类的静态变量的赋值动作static块中的语句合成<cinit>方法,通过该方法根据我们的意愿为静态变量赋值以及执行static块,该方法会被加锁,确保多线程情况下只有一个线程能初始化成功,利用该特性可以实现单例模式。虚拟机规定了有且只有遇到以下情况时必须先确保对应类的初始化完成(加载、准备必然在此之前):

    • 遇到new、getstatic、putstatic或invokestatic这四条字节码指令时。能够生成这四条指令的典型Java代码场景有:
      • 使用new关键字实例化对象的时候。
      • 读取或设置一个类型的静态字段(被final修饰、已在编译期把结果放入常量池的静态字段除外)的时候。
      • 调用一个类型的静态方法的时候。
    • 反射调用类时。
    • 当初始化类的时候,如果发现其父类还没有进行过初始化,则需要先触发其父类的初始化。
    • 当虚拟机启动时,用户需要指定一个要执行的主类(包含main()方法的那个类),虚拟机会先初始化这个主类。
    • 当使用JDK 7新加入的动态语言支持时,如果一个java.lang.invoke.MethodHandle实例最后的解析结果为REF_getStatic、REF_putStatic、REF_invokeStatic、REF_newInvokeSpecial四种类型的方法句柄,并且这个方法句柄对应的类没有进行过初始化,则需要先触发其初始化。
    • 当一个接口中定义了JDK 8新加入的默认方法(被default关键字修饰的接口方法)时,如果有这个接口的实现类发生了初始化,那该接口要在其之前被初始化。

    下面分析几个案例代码,读者们可以先思考后再运行代码看看和自己想的是否一样。

    案例一

    先定义如下两个类:

    public class SuperClazz {
    	static 	{
    		System.out.println("SuperClass init!");
    	}
    	public static int value=123;
    	public static final String HELLOWORLD="hello world";
    	public static final int WHAT = value;
    }
    
    public class SubClaszz extends SuperClazz {
    	static{
    		System.out.println("SubClass init!");
    	}
    
    }

    然后进行下面的调用:

    public class Initialization {
    	public static void main(String[]args){
    		Initialization initialization = new Initialization();
    		initialization.M1();
    	}
    	
    	public void M1(){
    		System.out.println(SubClaszz.value);
    	}
    }

    第一个案例是通过子类去引用父类中的静态变量,两个类都会加载和初始化么?打印结果看看:

    SuperClass init!
    123

    可以看到只有父类初始化了,那么父类必然是加载了的,问题就在于子类有没有被加载呢?可以加上参数:-XX:+TraceClassLoading再执行(该参数的作用就是打印被加载了的类),可以看到子类是被加载了的。所以通过子类引用父类静态变量,父子类都会被加载,但只有父类会进行初始化
    为什么呢?反编译后可以看到生成了如下指令:

    0: getstatic     #5                  // Field java/lang/System.out:Ljava/io/PrintStream;
    3: getstatic     #6                  // Field ex7/init/SubClaszz.value:I
    6: invokevirtual #7                  // Method java/io/PrintStream.println:(I)V
    9: return

    关键就是getstatic指令就会触发类的初始化,但是为什么子类不会初始化呢?因为这个变量是来自于父类的,为了提高效率,所以虚拟机进行了优化,这种情况只需要初始化父类就行了。

    案例二

    调用下面的方法:

    public void M2(){
    		SubClaszz[]sca = new SubClaszz[10];
    	}

    执行后可以发现,使用数组,不会触发初始化,但父子类都会被加载

    案例三

    public void M3(){
    		System.out.println(SuperClazz.HELLOWORLD);
    	}

    引用常量不会触发类的加载和初始化,因为常量在编译后就已经存在当前class的常量池。

    案例四

    public void M4(){
    		System.out.println(SubClaszz.WHAT);
    	}

    通过常量去引用其它的静态变量会发生什么呢?这个和案例一结果是一样的。

    类加载器

    类加载器和双亲委派模型

    在我们平时开发中,确定一个类需要通过完全限定名,而不能简单的通过名字,因为在不同的路径下我们是可以定义同名的类的。那么在虚拟机中又是怎么区分类的呢?在虚拟机中需要类加载器+完全限定名一起来指定一个类的唯一性,即相同限定名的类若由两个不同的类加载器加载,那虚拟机就不会把它们当做一个类。从这里我们可以看出类加载器一定是有多个的,那么不同的类加载器是怎么组织的?它们又分别需要加载哪些类呢?

    a851f3e1be9c92d981d1853dfdd58093.png


    从虚拟角度看,只有两种类型的类加载器:启动类加载器(BootstrapClassLoader)和非启动类加载器。前者是C++实现,属于虚拟机的一部分,后者则是由Java实现的,独立于虚拟机的外部,并且全部继承自抽象类java.lang.ClassLoader。
    但从Java本身来看,一直保持着三层类加载器双亲委派的结构,当然除了Java本身提供的三层类加载器,我们还可以自定义实现类加载器。如上图,上面三个就是原生的类加载器,每一个都是下一个类加载器的父加载器,注意这里都是采用组合而非继承。当开始加载类时,首先交给父加载器加载,父加载器加载了子加载器就不用再加载了,而若是父加载器加载不了,就会交给子加载器加载,这就是双亲委派机制。这就好比工作中遇到了无法处理的事,你会去请示直接领导,直接领导处理不了,再找上层领导,然后上层领导觉得这是个小事,不用他亲自动手,就让你的直接领导去做,接着他又交给你去做等等。下面来看看每个类加载器的具体作用:

    • BootstrapClassLoader:启动类加载器,顾名思义,这个类加载器主要负责加载JDK lib包,以及-Xbootclasspath参数指定的目录,并且虚拟机对文件名进行了限定,也就是说即使我们自己写个jar放入到上述目录,也不会被加载。由于该类加载器是C++使用,所以我们的Java程序中无法直接引用,调用java.lang.ClassLoader.getClassLoader()方法时默认返回的是null。
    • ExtClassLoader:扩展类加载器,主要负责加载JDK lib/ext包,以及被系统变量java.ext.dirs指向的所有类库,这个类库可以存放我们自己写的通用jar。
    • AppClassLoader:应用程序类加载器,负责加载用户classpath上的所有类。它是java.lang.ClassLoader.getSystemClassLoader()的返回值,也是我们程序的默认类加载器(如果我们没有自定义类加载器的话)。

    通过这三个类加载以及双亲委派机制,一个显而易见的好处就是,不同的类随它的类加载器天然具有了加载优先级,像Object、String等等这些核心类库自然就会在我们的应用程序类之前被加载,使得程序更安全,不会出现错误,Spring的父子容器也是这样的一个设计。通过下面这段代码可以看到每个类所对应的类加载器:

    public class ClassLoader {
        public static void main(String[] args) {
            System.out.println(String.class.getClassLoader()); //启动类加载器
            System.out.println(sun.net.spi.nameservice.dns.DNSNameService.class.getClassLoader());//拓展类加载器
            System.out.println(ClassLoader.class.getClassLoader());//应用程序类加载器
        }
    }

    输出:

    null
    sun.misc.Launcher$ExtClassLoader@4b67cf4d
    sun.misc.Launcher$AppClassLoader@14dad5dc

    破坏双亲委派模型

    刚刚我举了工作中的一个例子来说明双亲委派机制,但现实中我们不需要事事都去请示领导,同样类加载器也不是完全遵循双亲委派机制,在必要的时候是可以打破这个规则的。下面列举四个破坏的情况,在此之前我们需要先了解下双亲 委派的代码实现原理,在java.lang.ClassLoader类中有一个loadClass以及findClass方法:

    protected Class<?> loadClass(String name, boolean resolve)
            throws ClassNotFoundException
        {
            synchronized (getClassLoadingLock(name)) {
                // First, check if the class has already been loaded
                Class<?> c = findLoadedClass(name);
                if (c == null) {
                    long t0 = System.nanoTime();
                    try {
                        if (parent != null) {
                            c = parent.loadClass(name, false);
                        } else {
                            c = findBootstrapClassOrNull(name);
                        }
                    } catch (ClassNotFoundException e) {
                        // ClassNotFoundException thrown if class not found
                        // from the non-null parent class loader
                    }
    
                    if (c == null) {
                        // If still not found, then invoke findClass in order
                        // to find the class.
                        long t1 = System.nanoTime();
                        c = findClass(name);
    
                        // this is the defining class loader; record the stats
                        sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                        sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                        sun.misc.PerfCounter.getFindClasses().increment();
                    }
                }
                if (resolve) {
                    resolveClass(c);
                }
                return c;
            }
        }
    
        protected Class<?> findClass(String name) throws ClassNotFoundException {
            throw new ClassNotFoundException(name);
        }

    从上面可以看到首先是调用parent去加载类,没有加载到才调用自身的findClass方法去加载。也就是说用户在实现自定义类加载器的时候需要覆盖的是fiindClass而不是loadClass,这样才能满足双亲委派模型
    下面具体来看看破坏双亲委派的几个场景。

    第一次

    第一次破坏是在双亲委派模型出现之前, 因为该模型是在JDK1.2之后才引入的,那么在此之前,抽象类java.lang.ClassLoader就已经存在了,用户自定义的类加载器都会去覆盖该类中的loadClass方法,所以双亲委派模型出现后,就无法避免用户覆盖该方法,因此新增了findClass引导用户去覆盖该方法实现自己的类加载逻辑。

    SPI

    第二次破坏是由于这个模型本身缺陷导致的,因为该模型保证了类的加载优先级,但是有些接口是Java定义在核心类库中,但具体的服务实现是由用户提供的,这时候就不得不破坏该模型才能实现,典型的就是Java中的SPI机制(对SPI不了解的读者可以翻阅我之前的文章或是其它资料,这里不进行阐述)。J
    DBC的驱动加载就是SPI实现的,所以直接看到java.sql.DriverManager类,该类中有一个静态初始化块:

    static {
            loadInitialDrivers();
            println("JDBC DriverManager initialized");
        }
    
        private static void loadInitialDrivers() {
            String drivers;
            try {
                drivers = AccessController.doPrivileged(new PrivilegedAction<String>() {
                    public String run() {
                        return System.getProperty("jdbc.drivers");
                    }
                });
            } catch (Exception ex) {
                drivers = null;
            }
    
            AccessController.doPrivileged(new PrivilegedAction<Void>() {
                public Void run() {
    
                    ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
                    Iterator<Driver> driversIterator = loadedDrivers.iterator();
                    
                    try{
                        while(driversIterator.hasNext()) {
                            driversIterator.next();
                        }
                    } catch(Throwable t) {
                    // Do nothing
                    }
                    return null;
                }
            });
    
            println("DriverManager.initialize: jdbc.drivers = " + drivers);
    
            if (drivers == null || drivers.equals("")) {
                return;
            }
            String[] driversList = drivers.split(":");
            println("number of Drivers:" + driversList.length);
            for (String aDriver : driversList) {
                try {
                    println("DriverManager.Initialize: loading " + aDriver);
                    Class.forName(aDriver, true,
                            ClassLoader.getSystemClassLoader());
                } catch (Exception ex) {
                    println("DriverManager.Initialize: load failed: " + ex);
                }
            }
        }

    主要看ServiceLoader.load方法,这个就是通过SPI去加载我们引入java.sql.Driver实现类(比如引入mysql的驱动包就是com.mysql.cj.jdbc.Driver):

    public static <S> ServiceLoader<S> load(Class<S> service) {
            ClassLoader cl = Thread.currentThread().getContextClassLoader();
            return ServiceLoader.load(service, cl);
        }

    这个方法主要是从当前线程中获取类加载器,然后通过这个类加载器去加载驱动实现类(这个叫线程上下文类加载器,我们也可以使用这个技巧去打破双亲委派),那这里会获取到哪一个类加载器呢?具体的设置是在sun.misc.Launcher类的构造器中:

    public Launcher() {
            Launcher.ExtClassLoader var1;
            try {
                var1 = Launcher.ExtClassLoader.getExtClassLoader();
            } catch (IOException var10) {
                throw new InternalError("Could not create extension class loader", var10);
            }
    
            try {
                this.loader = Launcher.AppClassLoader.getAppClassLoader(var1);
            } catch (IOException var9) {
                throw new InternalError("Could not create application class loader", var9);
            }
    
            Thread.currentThread().setContextClassLoader(this.loader);
            String var2 = System.getProperty("java.security.manager");
            if (var2 != null) {
                SecurityManager var3 = null;
                if (!"".equals(var2) && !"default".equals(var2)) {
                    try {
                        var3 = (SecurityManager)this.loader.loadClass(var2).newInstance();
                    } catch (IllegalAccessException var5) {
                    } catch (InstantiationException var6) {
                    } catch (ClassNotFoundException var7) {
                    } catch (ClassCastException var8) {
                    }
                } else {
                    var3 = new SecurityManager();
                }
    
                if (var3 == null) {
                    throw new InternalError("Could not create SecurityManager: " + var2);
                }
    
                System.setSecurityManager(var3);
            }
    
        }

    可以看到设置的就是AppClassLoader。你可能会有点疑惑,这个类加载器加载类的时候不也是先调用父类加载器加载么,怎么就打破双亲委派了呢?其实打破双亲委派指的就是类的层次结构,延伸意思就是类的加载优先级,这里本应该是在加载核心类库的时候却提前将我们应用程序中的类库给加载到虚拟机中来了。

    Tomcat

    a135bf96a50c44dc4a87546e5493670d.png


    上图是Tomcat类加载的类图,前面三个不用说,CommonClassLoaderCatalinaClassLoaderSharedClassLoaderWebAppClassLoaderJspClassLoader则是Tomcat自己实现的类加载器,分别加载common包server包shared包WebApp/WEB-INF/lib包以及JSP文件,前面三个在tomcat 6之后已经合并到根目录下的lib目录下。而WebAppClassLoader则是每一个应用程序对应一个,JspClassLoader是每一个JSP文件都会对应一个,并且这两个类加载器都没有父类加载器,这也就违背了双亲委派模型。
    为什么每个应用程序需要单独的WebAppClassLoader实例?因为每个应用程序需要彼此隔离,假如在两个应用中定义了一样的类(完全限定名),如果遵循双亲委派那就只会存在一份了,另外不同的应用还有可能依赖同一个类库的不同版本,这也需要隔离,所以每一个应用程序都会对应一个WebAppClassLoader,它们共享的类库可以让SharedClassLoader加载,另外这些类加载加载的类对Tomcat本身来说也是隔离的(CatalinaClassLoader加载的)。
    为什么每个JSP文件需要对应单独的一个JspClassLoader实例?这是由于JSP是支持运行时修改的,修改后会丢弃掉之前编译生成的class,并重新生成一个JspClassLoader实例去加载新的class。
    以上就是Tomcat为什么要打破双亲委派模型的原因。

    OSGI

    OSGI是用于实现模块热部署,像Eclipse的插件系统就是利用OSGI实现的,这个技术非常复杂同时使用的也越来越少了,感兴趣的读者可自行查阅资料学习,这里不再进行阐述。

    总结

    类加载的过程让我们了解到一个类是如何被加载到内存中,需要经过哪些阶段;而类加载器和双亲委派模型则是告诉我们应该怎么去加载类、类的加载优先级是怎样的,其中的设计思想我们也可以学习借鉴;最后需要深刻理解的是为什么需要打破双亲委派,在遇到相应的场景时应该怎么做。

    ac95c26c382466acc03ade78f0cb316a.png

    乐于输出干货的Java技术公众号:程序猿it社区。公众号内都是技术文章、海量视频资源、精美脑图,关注即可获取!

    更多学习资料

    如果大家想要实时关注我更新的文章以及分享的干货的话,微信搜索:程序猿it社区

    展开全文
  • 1.什么是Busspringcloudbus使用轻量级消息代理将分布式系统的节点连接起来。然后,可以使用它来广播状态更改(例如配置更改)或其他管理指令。AMQPKafka broker实现包含在项目中。或者,在路径上找到的任何spring...

    1.什么是Bus

    springcloudbus使用轻量级消息代理将分布式系统的节点连接起来。然后,可以使用它来广播状态更改(例如配置更改)或其他管理指令。AMQP和Kafka broker实现包含在项目中。或者,在类路径上找到的任何springcloudstream绑定器都可以作为传输使用。

    通俗定义: bus称之为springcloud中消息总线,主要用来在微服务系统中实现远端配置更新时通过广播形式通知所有客户端刷新配置信息,避免手动重启服务的工作

    2.实现配置刷新原理

    3.搭建RabbitMQ服务

    可以看之前写的文章,在linux系统中安装rabbitmq

    4.实现自动配置刷新

    继续在上一个写的configserver项目中进行使用

    1.在所有项目中引入bus依赖

    org.springframework.cloud

    spring-cloud-starter-bus-amqp

    2.配置统一配置中心连接到mq

    spring.rabbitmq.host=192.168.52.130#连接主机

    spring.rabbitmq.port=5672#连接mq端口

    spring.rabbitmq.username=guest#连接mq用户名

    spring.rabbitmq.password=guest#连接mq密码

    3.远端配置中加入连接mq配置

    在上一个项目configserver得基础之上,看一看上篇文章,和在上面得配置一样,

    4.启动统一配置中心服务

    正常启动

    5.启动客户端服务

    加入bus组件之后客户端启动报错

    原因springcloud中默认链接不到远程服务器不会报错,但是在使用bus消息总线时必须开启连接远程服务失败报错

    spring.cloud.config.fail-fast=true

    在configclient项目中添加,记得先引入bus依赖

    6.修改远程配置后在配置中心服务通过执行post接口刷新配置

    当修改远程配置之后不进行刷新配置,那么访问得还是原来得数据,必须进行post接口刷新配置

    首先再configserver7878得配置文件中添加

    management.endpoints.web.exposure.include=*

    r然后重启再进行刷新

    此时是通过配置server来进行得刷新,配置server连接得所有节点都得到了刷新,

    可以看到在配置文件中修改之后得数据了

    7.通过上述配置就实现了配置统一刷新

    5.指定服务刷新配置

    1.说明

    默认情况下使用curl -X POST http://localhost:7878/actuator/bus-refresh

    这种方式刷新配置是全部广播形式,也就是所有的微服务都能接收到刷新配置通知,但有时我们修改的仅仅是某个服务的配置,这个时候对于其他服务的通知是多余的,因此就需要指定服务进行通知

    2.指定服务刷新配置实现

    5.集成webhook实现自动刷新

    1.配置webhooks

    添加webhooks

    在webhooks中添加刷新配置接口

    使用natapp来进行内网穿透,直接看官网教程就可以了

    使用natapp作为公网地址之后会出现400错误

    2.解决400错误问题

    在配置中心服务端加入过滤器进行解决(springcloud中一个坑)

    @Component

    public class UrlFilter implements Filter {

    @Override

    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override

    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {

    HttpServletRequest httpServletRequest = (HttpServletRequest)request;

    HttpServletResponse httpServletResponse = (HttpServletResponse)response;

    String url = new String(httpServletRequest.getRequestURI());

    //只过滤/actuator/bus-refresh请求

    if (!url.endsWith("/bus-refresh")) {

    chain.doFilter(request, response);

    return;

    }

    //获取原始的body

    String body = readAsChars(httpServletRequest);

    System.out.println("original body: "+ body);

    //使用HttpServletRequest包装原始请求达到修改post请求中body内容的目的

    CustometRequestWrapper requestWrapper = new CustometRequestWrapper(httpServletRequest);

    chain.doFilter(requestWrapper, response);

    }

    @Override

    public void destroy() {

    }

    private class CustometRequestWrapper extends HttpServletRequestWrapper {

    public CustometRequestWrapper(HttpServletRequest request) {

    super(request);

    }

    @Override

    public ServletInputStream getInputStream() throws IOException {

    byte[] bytes = new byte[0];

    ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);

    return new ServletInputStream() {

    @Override

    public boolean isFinished() {

    return byteArrayInputStream.read() == -1 ? true:false;

    }

    @Override

    public boolean isReady() {

    return false;

    }

    @Override

    public void setReadListener(ReadListener readListener) {

    }

    @Override

    public int read() throws IOException {

    return byteArrayInputStream.read();

    }

    };

    }

    }

    public static String readAsChars(HttpServletRequest request)

    {

    BufferedReader br = null;

    StringBuilder sb = new StringBuilder("");

    try

    {

    br = request.getReader();

    String str;

    while ((str = br.readLine()) != null)

    {

    sb.append(str);

    }

    br.close();

    }

    catch (IOException e)

    {

    e.printStackTrace();

    }

    finally

    {

    if (null != br)

    {

    try

    {

    br.close();

    }

    catch (IOException e)

    {

    e.printStackTrace();

    }

    }

    }

    return sb.toString();

    }

    }

    展开全文
  • 执行sql语句的API,它由一组java语言编写的类和接口组成 JDBC提供一个操作数据的标准,包含操作数据库的规范,,接口,方法,自己并没有实现 idea通过jdbc连接mysql,查询wangtao数据库中的Class_name表中的name...
  • 1. SSLConnectionSocketFactory 这个的作用是什么 下的SSLSocketFactory 有什么区别 找遍了搜索没有找到相关的文档都 基本都是营销号粘贴复制 1. 这几行代码 它以及创建了TLS的SSLContext连接了 为什么...
  • http协议长连接和短链接

    千次阅读 2018-09-11 09:23:19
     HTTP1.1规定了默认保持长连接(HTTP persistent connection ,也有翻译为持久连接),数据传输完成了保持TCP连接不断开(不发RST、不四次握手),等待在同域名下继续这个通道传输数据;相反的就是短连接。  ...
  • 由于每次做东西,无论是开发还测试,都要写连接数据库的及方法,其实也没什么大的差别,而且现有的JDBC提供的接口功能还是很有限制...所以我写了一个通用些连接数据库的,其中有三个:1.DBConn.java:主要用来连接和关闭
  • Java类和对象总结

    2019-10-22 20:35:26
    面向对象就是代码()来描述客观世界的事物的一种方式,一个主要包含一个事物的属性行为。 面向对象注重的是对象,也就是参与过程所涉及到的主体。是通过逻辑将一个个功能实现连接起来 面向过程:C语言 ...
  • JDBC连接

    2020-05-28 13:55:29
    1.什么是JDBC:Java database connection(java...4.这里呢我在创建一个名称为BassDao的数据库连接类,封装成方法来进行连接和销毁 public class bassDao { //useUnicode=true(支持中文编码)&characterEncodin
  • 但是Sun公司把那些访问网络的难题细节(信息块的连接、打包拆包,块的来回运输,以及握手等等)都封在它的net包中了,通过调用net包中的的方法,你可以轻松访问操作网上的其它电脑。Java的这种网络编程模式...
  • 数据库连接

    2016-12-18 23:33:00
    概述为什么要使用数据库连接池?数据库频繁的连接和关闭连接会...这四个是要导入项目的jar,画红框的是DBCP连接池技术要的jar DBCP下载链接 POOL下载链接代码 测试 public class Test { public static void
  • 感谢各位的关注,不过我找到了一个刚好的方法,Spring里有个DataSourceUtil的,通过getConnection方法可以把当前连接和当前线程绑定,这样两种持久化的方式使用的是同一个connection,也就达到了事务一致。
  • JDBC数据库连接

    2017-09-26 16:44:43
    JDBC是什么:JDBC(Java DataBase Connectivity,java数据库连接)是一种用于执行SQL语句的Java API,可以为多种关系数据库提供统一访问,它由一组Java语言编写的类和接口组成。 JDBC能干什么:JDBC能与数据库建立...
  • 神奇的是:java的IO里的各种各样的竟然把上面的所有IO情况(文件、控制台、网络连接)都能一把抓轻松搞定。这章我们学文件,控制台, 下章我们学网络连接。 更多请:...
  • JDBC简单连接

    2019-10-29 20:38:02
    它由一组Java语言编写的类和接口组成 JDBC提供了一种操作数据的标准 JDBC的目标是使Java程序员使用JDBC可以连接任何提供了JDBC驱动程序的数据库系统 JDBC的API java.sql包装的就是JDBC的API. 各大数据库厂商就...
  • 09.连接

    2021-01-02 13:20:30
    什么要使用连接池? 以往我们每次与数据库交互都回去创建链接,完之后需要销毁链接,会占用大量的系统资源,效率低下,而且任务量巨大的时候会导致数据库链接超出最大上限,程序直接崩溃。 什么连接池? 一种...
  • 几个问题全是关于接口,接口有什么用?为什么接口?什么时候该使用接口?很庆幸他们不是问我Java如何连接SQL Server,或者是如何开发J2EE,这问题有杀伤力,避之则吉。今年计算机学院本科有个毕业设计课题是做...
  • JDBC连接数据库

    2020-07-27 23:03:39
    JDBC,即Java Database Connectivity,Java数据库连接,是一种用于执行SQL语句的Java API,它是Java数据库连接规范,这个API由java.sql.* , javax.sql.*包中的一些类和接口组成,它为Java开发人员操作数据库提供了一...
  • 文章目录前言一、JDBC是什么?...JDBC(Java DataBase Connectivity,java数据库连接)是一种用于执行SQL语句的Java API,可以为多种关系数据库提供统一访问,它由一组Java语言编写的类和接口组成。JDBC提供了
  • JDBC实现数据库连接

    2020-06-15 16:25:33
    JDBC(java数据库连接)是一种用于执行SQL语句的Java API,可以为多种关系数据库提供统一访问,它由一组Java语言编写的类和接口组成。 (二)JDBC的本质 JDBC本质上是一种规范,据此可以构建更高级的工具接口,...
  • JDBC Java数据库连接

    2017-11-20 21:00:45
    API,可以为多种关系数据库提供统一访问,它由一组Java语言编写的类和接口组成。即可以实现客户端与服务器端通信,执行数据库操作的一种技术         Java连接数据库的过程 应用程序---加载驱动---访问数据库...
  • 基本常识: ?>可以省略 字符串连接符是 . 注释 // 变量 变量必须首字母为$,以...当我们”echo”指令输出布尔类型时,如果是“true”则输出的是“1”,“false”则什么也不输出 当双引号中包含变量时,变量会与双引
  • 中控屏:不仅仅是娱乐商务,还是用户与车辆交互的入口,它与各类总线(以太网、CAN、USB、Lin)连接,提供包含IVI域(导航、语音、音乐等)、车辆控制域(空调、座椅、灯光、驾驶、ADAS、DVR、AVM等)、安全安防...
  • Java数据库连接(JDBC)由一组 Java 编程语言编写的类和接口组成。JDBC 为工具/数据库开发人员提供了一个标准的 API,使他们能够纯Java API 来编写数据库应用程序。 在连接数据库之前,往往需要在eclipse你的...
  • java常用

    2018-08-09 14:23:34
    1.包装:将基本类型封装到一个中,包含属性方法,方便...为什么包装? 字符串的连接 方法:+,concat()方法 concat()方法必须将结果再赋给新的对象 字符串截取: StringBuild与StringBuffer:...
  • 什么是IP地址、子网掩码网关

    千次阅读 2017-03-17 12:41:51
     IP地址有一个32位的连接地址,由4个8位字段组成,8位字段称为8位位组,每个8位位组之间点号隔开,用于标识TCP/IP宿主机。每个IP地址都包含两部分:网络ID主机ID,网络ID 标识在同一个物理网络上的所有宿主机,主机ID...
  • java开源1

    千次下载 热门讨论 2013-06-28 09:14:34
    往好了用什么都能干,就是不能让一个网站下线。 FTP客户端Java类库 ftp4j ftp4j是一个FTP客户端Java类库,实现了FTP客户端应具有的大部分功能文件(包括上传下 载),浏览远程FTP服务器上的目录文件,创建、...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 578
精华内容 231
关键字:

包和类用什么连接