精华内容
下载资源
问答
  • 目前的需求是去一台FTP服务器上边...**ftpHelper.getFtpClient().retrieveFile(currentFile, fos)**,但是不明白啥速度相差那么大 ![图片说明](https://img-ask.csdn.net/upload/202007/30/1596097672_718187.png)
  • 相关阅读:为什么要分布式 id ?分布式 id 生成方案有哪些? 分布式事务 分布式事务就是指事务的参与者、支持事务的服务器、资源服务器以及事务管理器分别位于不同的分布式系统的不同节点之上。 简单的说,就是一次...
  • 相关阅读:为什么要分布式 id ?分布式 id 生成方案有哪些? 分布式事务 分布式事务就是指事务的参与者、支持事务的服务器、资源服务器以及事务管理器分别位于不同的分布式系统的不同节点之上。 简单的说,就是一次...
  • 为什么查询操作会变了? Redis Hash rehash过程 为什么使用哈希表作为Redis的索引 当我们分析理解了Redis数据结构,可以为了我们在使用Redis的时候,正确抉择数据类型使用,提升系统性能。 Spring技术内幕深入...

    前言

    在实际开发,Redis使用会频繁,那么在使用过程中我们该如何正确抉择数据类型呢?哪些场景下适用哪些数据类型。而且在面试中也很常会被面试官问到Redis数据结构方面的问题:

    • Redis为什么快呢?
    • 为什么查询操作会变慢了?
    • Redis Hash rehash过程
    • 为什么使用哈希表作为Redis的索引

    当我们分析理解了Redis数据结构,可以为了我们在使用Redis的时候,正确抉择数据类型使用,提升系统性能。

    Spring技术内幕深入解析Spring架构与设计原理

    Spring核心实现

    image

    Spring组件实现

    image

    Spring应用实现

    image

    Spring源码深度解析

    image

    image

    spring面试专题及答案解析

    image

    image

    image

    毋庸置疑,Spring 早已成为 Java 后端开发事实上的行业标准,无数的公司选择 Spring 作为基础的开发框架,大部分 Java 后端程序员在日常工作中也会接触到Spring ,因此,如何用好 Spring ,也就成为成为 Java 程序员的必修课之一。大家一起加油吧

    更多:Java进阶核心知识集

    包含:JVM,JAVA集合,网络,JAVA多线程并发,JAVA基础,Spring原理,微服务,Zookeeper,Kafka,RabbitMQ,Hbase,MongoDB,Cassandra,设计模式,负载均衡,数据库,一致性哈希,JAVA算法,数据结构,加密算法,分布式缓存等等

    image

    点击免费领取我的学习笔记:学习视频+大厂面试真题+微服务+MySQL+Java+Redis+算法+网络+Linux+Spring全家桶+JVM+学习笔记图

    高效学习视频

    https://docs.qq.com/doc/DSmxTbFJ1cmN1R2dB)**

    高效学习视频

    image

    展开全文
  • Thinking.In.Java

    2012-03-21 22:35:53
    大家也会从中了解到是什么使得Java如此特别,它为什么取得了这么大的成功,以及与面向对象的分析与设计有关的问题。 (2) 第2章:一切都是对象 本章将大家带到可以着手写自己的第一个Java程序的地方,所以必须对一些...
  • Java9发布已经有一年了,跟Java8相比,从目录对比就看得出来差别相当大。 实际上Java9最大的变化就是JDK模块化(Modular)。 那么,模块化的目的是什么呢?... (1)下载慢,部署。  (2)内...

    Java9发布已经有一年了,跟Java8相比,从目录对比就看得出来差别相当大。

    实际上Java9最大的变化就是JDK模块化(Modular)。

    那么,模块化的目的是什么呢?

    官方的说法是:

    之前版本的Java存在一些问题:

    1、JDK和JRE作为一个整体部署,体积太大(JDK8只是rt.jar一个包就超过60MB)。体积大有如下缺点:

      (1)下载慢,部署慢。

      (2)内存较小的设备无法部署。这跟Java从诞生时的口号Write once , Run anywhere不符。

      (3)大量部署在云端,累计占用的内存非常可观。

    2、访问控制粒度不够细。

      所有public关键字定义的属性或者方法,在任何地方都可以被调用,这影响了代码的封装性。例如在import了sun.*之后,sun.*下面大量用不着的API也暴露出来了(最直观的例子就是使用IDE时,在对象名后面输入点“.”自动会弹出所有public的属性和方法清单以供选择)。

      另外,之前的权限控制针对的是类与类之间的关系,模块化针对的是组件之间的控制。模块化的目标之一是,利用一组逻辑独立的组件搭建出完整的系统。  

    3、Dependency Hell。

      依赖地狱是一个诙谐的说法,指的是由Java类加载机制的特性引发的一系列问题,包括JAR包冲突、运行时类缺失。

    为了解决以上这些问题,Java9引入了模块系统JPMS。

      这里有个问题需要明确下,JPMS和OSGI的模块化还是有区别的,可以参考文章《Java 9,OSGi和模块化的未来》。

      


     【说明】

    1、JAR包冲突

      有时classpath中不同的JAR包会包含限定名完全相同的类。造成这种现象的原因有很多,例如一个Fat JAR包含了某个类A的版本v1,另一个Fat JAR包含了该类A的另一个版本v2,这时就会导致同一个类的两个版本冲突。
      JVM的类加载机制会从classpath中第一个包含某个类的JAR包里加载该类,这个被加载的类将会“屏蔽”该类的其他版本(可能真正需要的却是这个版本),使这些类变得不可用。这样会导致程序的行为不是我们预想的那样,结果可能很糟。

    2、运行时类缺失(这是我自己的说法)

      有些依赖如第三方JAR包,Java运行时系统只有在真正需要访问这些JAR包时才能检测到它所依赖的某些类找不到。这时运行时系统将会抛出NoClassDefFoundError异常,进而导致正在运行的应用程序崩溃。

    3、Fat JAR

    Fat JAR是将所有依赖和资源文件都打包成一个JAR包,它可能包含了另一个它依赖的JAR包。

    【参考】

    https://www.jianshu.com/p/053a5ca89bbb

    https://my.oschina.net/lt0314/blog/1544711

    http://udn.yyuap.com/forum.php?mod=viewthread&tid=113385

    https://stackoverflow.com/questions/373193/what-is-classpath-hell-and-is-was-it-really-a-problem-for-java

     

    转载于:https://www.cnblogs.com/tigerhsu/p/9877733.html

    展开全文
  • java 面试题 总结

    2009-09-16 08:45:34
    为什么要有GC?  GC是垃圾收集的意思(Gabage Collection),内存处理是编程人员容易出现问题的地方,忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃,Java提供的GC功能可以自动监测对象是否超过作用域...
  • 有时候我们会遇到jar包冲突的bug,或者说就是想单纯的看看我那简单的一句implementations到底导入了多少个jar包,这也是为什么Groovy语言的Gradle和XML语言的Maven相比,前者就能如此简洁。这时候,就可以去Android...
  • 为什么要有GC?  GC是垃圾收集的意思(Gabage Collection),内存处理是编程人员容易出现问题的地方,忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃,Java提供的GC功能可以自动监测对象是否超过作用域...
  • 本例基于IDEA: 1.先建立项目 new出一个projec 起个什么名字比较好呢,哈哈哈哈! 那么就叫他德玛西亚吧! 然后呢基于maven,大家事先准备好maven哦...手动斜眼 等待载入完成,好无聊,好为什么!!! 终于下载完...

    本例基于IDEA:

    1.先建立项目

    new出一个projec

    QQ截图20160324155059

    起个什么名字比较好呢,哈哈哈哈!

    那么就叫他德玛西亚吧!

    QQ截图20160324155452

    然后呢基于maven,大家事先准备好maven哦。

    QQ截图20160324155435

    那么接下来就是设置这个狂拽酷炫的项目名字

    QQ截图20160324155803

    好了完成我们正式进入主界面把。

    2.IDEA的自动生成模板项目

    QQ截图20160324160606

    左上角的自动导入ok既然这么有心我们就接受好了!手动斜眼

    等待载入完成,好无聊,好慢,为什么!!!

    QQ截图20160324162027

    终于下载完成,太慢了,上网一搜发现是从远端仓库获取的我们可以让他在本地获取

    QQ截图20160324162125

    测试了下速度瞬间鸟枪换炮。

    3.然后我们先来往maven添加架包

    可以下看下文件结构,再加不迟

    QQ截图20160324162412

    一个标准的web项目成型

    下面我们来添加倚赖包

    <!-- 配置仓库 -->
    
      <properties>
        <java-version>1.6</java-version>
        <spring.version>4.0.2.RELEASE</spring.version>
        <mybatis.version>3.2.6</mybatis.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <org.aspectj-version>1.7.3</org.aspectj-version>
      </properties>
    
    
      <dependencies>
        <!-- junit lib -->
        <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>3.8.1</version>
          <scope>test</scope>
        </dependency>
    
        <!-- slf4j lib -->
        <dependency>
          <groupId>org.slf4j</groupId>
          <artifactId>slf4j-log4j12</artifactId>
          <version>1.7.5</version>
          <scope>provided</scope>
        </dependency>
    
        <!-- spring核心包 -->
        <!-- jersey中已存在 -->
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-core</artifactId>
          <version>${spring.version}</version>
        </dependency>
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-web</artifactId>
          <version>${spring.version}</version>
        </dependency>
    
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-oxm</artifactId>
          <version>${spring.version}</version>
        </dependency>
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-orm</artifactId>
          <version>${spring.version}</version>
        </dependency>
    
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-tx</artifactId>
          <version>${spring.version}</version>
        </dependency>
    
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-jdbc</artifactId>
          <version>${spring.version}</version>
        </dependency>
    
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-webmvc</artifactId>
          <version>${spring.version}</version>
        </dependency>
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-aop</artifactId>
          <version>${spring.version}</version>
        </dependency>
    
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-context-support</artifactId>
          <version>${spring.version}</version>
        </dependency>
    
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-test</artifactId>
          <version>${spring.version}</version>
        </dependency>
    
        <!-- mybatis核心包 -->
        <dependency>
          <groupId>org.mybatis</groupId>
          <artifactId>mybatis</artifactId>
          <version>${mybatis.version}</version>
        </dependency>
    
        <!-- mybatis/spring包 -->
        <dependency>
          <groupId>org.mybatis</groupId>
          <artifactId>mybatis-spring</artifactId>
          <version>1.2.2</version>
        </dependency>
    
        <!-- tomcat jdbc -->
        <dependency>
          <groupId>org.apache.tomcat</groupId>
          <artifactId>tomcat-jdbc</artifactId>
          <version>7.0.56</version>
          <scope>provided</scope>
        </dependency>
    
        <!-- 导入java ee jar 包 -->
        <dependency>
          <groupId>javax</groupId>
          <artifactId>javaee-api</artifactId>
          <version>7.0</version>
        </dependency>
    
        <!-- 导入dbcp的jar包,用来在applicationContext.xml中配置数据库 -->
        <dependency>
          <groupId>commons-dbcp</groupId>
          <artifactId>commons-dbcp</artifactId>
          <version>1.2.2</version>
        </dependency>
    
        <!-- mysql connector -->
        <dependency>
          <groupId>mysql</groupId>
          <artifactId>mysql-connector-java</artifactId>
          <version>5.1.30</version>
        </dependency>
    
        <!-- 新增 Jersey 框架支持 2014-11-18 14:19:41 -->
        <dependency>
          <groupId>org.glassfish.jersey.ext</groupId>
          <artifactId>jersey-spring3</artifactId>
          <version>2.4.1</version>
          <exclusions>
            <exclusion>
              <groupId>org.springframework</groupId>
              <artifactId>spring-core</artifactId>
            </exclusion>
            <exclusion>
              <groupId>org.springframework</groupId>
              <artifactId>spring-web</artifactId>
            </exclusion>
            <exclusion>
              <groupId>org.springframework</groupId>
              <artifactId>spring-beans</artifactId>
            </exclusion>
          </exclusions>
        </dependency>
        <dependency>
          <groupId>org.glassfish.jersey.media</groupId>
          <artifactId>jersey-media-json-jackson</artifactId>
          <version>2.4.1</version>
        </dependency>
    
        <!-- jacson依赖包 -->
        <dependency>
          <groupId>org.codehaus.jackson</groupId>
          <artifactId>jackson-mapper-asl</artifactId>
          <version>1.9.3</version>
        </dependency>
        <dependency>
          <groupId>org.codehaus.jackson</groupId>
          <artifactId>jackson-jaxrs</artifactId>
          <version>1.8.1</version>
        </dependency>
    
        <!-- Logging -->
        <dependency>
          <groupId>log4j</groupId>
          <artifactId>log4j</artifactId>
          <version>1.2.17</version>
        </dependency>
    
        <!-- Servlet -->
        <dependency>
          <groupId>javax.servlet</groupId>
          <artifactId>servlet-api</artifactId>
          <version>2.5</version>
          <scope>provided</scope>
        </dependency>
        <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>4.10</version>
        </dependency>
    
    
      </dependencies>

    所有包在此包括很多个

    其中有

    junit lib 
    slf4j lib
    spring核心包
    mybatis核心包
    mybatis/spring包
    tomcat jdbc
    java ee jar 包
    导入dbcp的jar包,用来在applicationContext.xml中配置数据库
    mysql connector
    Jersey 框架支持
    jacson依赖包
    Logging
    Servlet

    添加之后茫茫多的依赖都要晕了都。

     

    然后在最后IDEA不能自动识别xml配置文件我们可以在pom里面设置自动刷新

    <resources>
          <resource>
            <directory>src/main/java</directory>
            <excludes>
              <exclude>**/*.java</exclude>
            </excludes>
          </resource>
        </resources>

    4.下面我们就开始写配置文件

    从那里开始呢当然是web.xml了所有的访问入口

    <?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xmlns="http://java.sun.com/xml/ns/javaee"
             xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
             xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
             http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" version="2.5">
      <display-name>DEMAXIYA - Restful Web Application</display-name>
      
    </web-app>

    修改修改头文件,以及默认的名字,那么我们就开始了

    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
     </listener>

    首先是入口,

    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring-mybatis.xml</param-value>
      </context-param>

    配置context-param这个节点,然后让spring去读取这个文件来实现我们的配置

    然后就开始配置spring-mybatis.xml这个文件

    首先

    <?xml version="1.0" encoding="UTF-8"?>

    这个是声明文件

    然后接下来是beans文件

    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:p="http://www.springframework.org/schema/p"
           xmlns:context="http://www.springframework.org/schema/context"
           xmlns:mvc="http://www.springframework.org/schema/mvc"
           xmlns:tx="http://www.springframework.org/schema/tx"
           xmlns:jdbc="http://www.springframework.org/schema/jdbc"
           xmlns:aop="http://www.springframework.org/schema/aop"
           xmlns:task="http://www.springframework.org/schema/task"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-3.1.xsd
           http://www.springframework.org/schema/mvc
           http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
           http://www.springframework.org/schema/jdbc
           http://www.springframework.org/schema/jdbc/spring-jdbc-3.1.xsd
           http://www.springframework.org/schema/tx
           http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
           http://www.springframework.org/schema/task
           http://www.springframework.org/schema/task/spring-task-3.1.xsd
           http://www.springframework.org/schema/aop
           http://www.springframework.org/schema/aop/spring-aop-3.1.xsd">

    这个文件的主要作用就是

    1、避免命名冲突,像Java中的package一样 

    2、将不同作用的标签分门别类(像Spring中的tx命名空间针对事务类的标签,context命名空间针对组件的标签) 

    然后我们新建java包,并且将其转化成源码包,然后新建我们的包

    com.demaxiya

    <!-- 自动扫描 -->
        <context:component-scan base-package="com.demaxiya.." />

    然后可以让spring自动扫描里面的加commpent类来加载

    xmlns:context="http://www.springframework.org/schema/context"
    <!-- 自动扫描 -->
    <context:component-scan base-package="com.demaxiya.." />

    相对应的

    xmlns="http://www.springframework.org/schema/beans"
    <!-- 引入配置文件 -->
    <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="location" value="classpath:jdbc.properties" />
    </bean>

    加入jdbc配置文件,然后配置jdbc参数

    driver=com.mysql.jdbc.Driver
    url_Master=jdbc:mysql://ip:port/(数据库名字)?useUnicode=true&characterEncoding=utf8&useOldAliasMetadataBehavior=true&autoReconnect=true&autoReconnectForPools=true
    username_Master=xxx
    password_Master=xxx
    
    url_Slave=jdbc:mysql://ip:port/(数据库名字)?useUnicode=true&characterEncoding=utf8&useOldAliasMetadataBehavior=true&autoReconnect=true&autoReconnectForPools=true
    username_Slave=xxx
    password_Slave=xxx
    
    #\u5B9A\u4E49\u521D\u59CB\u8FDE\u63A5\u6570  
    initialSize=0
    #\u5B9A\u4E49\u6700\u5927\u8FDE\u63A5\u6570  
    maxActive=20
    #\u5B9A\u4E49\u6700\u5927\u7A7A\u95F2  
    maxIdle=20
    #\u5B9A\u4E49\u6700\u5C0F\u7A7A\u95F2  
    minIdle=1
    #\u5B9A\u4E49\u6700\u957F\u7B49\u5F85\u65F6\u95F4  
    maxWait=60000
    <!-- 主数据库节点,更新写入 -->
        <bean id="Master" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
            <property name="driverClassName" value="${driver}" />
            <property name="url" value="${url_Master}" />
            <property name="username" value="${username_Master}" />
            <property name="password" value="${password_Master}" />
            <property name="initialSize" value="${initialSize}"></property>        <!-- 初    始化连接大小 -->
            <property name="maxActive" value="${maxActive}"></property>                <!-- 连接池最大数量 -->
            <property name="maxIdle" value="${maxIdle}"></property>                    <!-- 连接池最大空闲 -->
            <property name="minIdle" value="${minIdle}"></property>                    <!-- 连接池最小空闲 -->
            <property name="maxWait" value="${maxWait}"></property>                    <!-- 获取连接最大等待时间 -->
        </bean>
    
        <!-- 从数据库节点,读取 -->
        <bean id="Slave" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
            <property name="driverClassName" value="${driver}" />
            <property name="url" value="${url_Slave}" />
            <property name="username" value="${username_Slave}" />
            <property name="password" value="${password_Slave}" />
            <property name="initialSize" value="${initialSize}"></property>        <!-- 初    始化连接大小 -->
            <property name="maxActive" value="${maxActive}"></property>                <!-- 连接池最大数量 -->
            <property name="maxIdle" value="${maxIdle}"></property>                    <!-- 连接池最大空闲 -->
            <property name="minIdle" value="${minIdle}"></property>                    <!-- 连接池最小空闲 -->
            <property name="maxWait" value="${maxWait}"></property>                    <!-- 获取连接最大等待时间 -->
        </bean>

    配置一个或者多个数据库连接

    <!-- 设置默认数据连接 -->
        <bean id="multipleDataSource" class="com.demaxiya.utils.ChangeDatabases.MultipleDataSource">
            <property name="defaultTargetDataSource" ref="Master"/>
            <property name="targetDataSources">
                <map>
                    <entry key="Master" value-ref="Master"/>
                    <entry key="Slave" value-ref="Slave"/>
                </map>
            </property>
        </bean>

    设置默认数据库连接,本例有两个数据库连接,为了项目做读写分离做准备

    <!-- spring和MyBatis完美整合,不需要mybatis的配置映射文件 -->
        <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
            <property name="dataSource" ref="multipleDataSource" />
            <property name="configLocation" value="classpath:mybatis.xml" />
            <property name="mapperLocations" value="classpath:com/demaxiya/mapper/*.xml"></property>
        </bean>
    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
    "http://mybatis.org/dtd/mybatis-3-config.dtd">
    
    <configuration>
        <settings>
            <setting name="callSettersOnNulls" value="true"/>
        </settings>
       <!-- 配置实体类短别名 -->
         <typeAliases>
              <typeAlias alias="Account" type="com.demaxiya.entities.Account"/>
              <typeAlias alias="PageEx" type="com.demaxiya.entities.PageEx"/>
             <typeAlias alias="PubSource" type="com.demaxiya.entities.PubSource"/>
        </typeAliases>
       
        <!-- 配置Mapper  -->
        <mappers>
        </mappers>
    
    </configuration>

    配置这个文件可以在mybatis .xml文件中使用别名

    <!-- DAO接口所在包名,Spring会自动查找其下的类 -->
        <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
            <property name="basePackage" value="com.nico.dao" />
            <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>
        </bean>
    
        <!-- (事务管理)transaction manager, use JtaTransactionManager for global tx -->
        <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            <!-- 只有写入时候需要开启事务 -->
            <property name="dataSource" ref="Master" />
        </bean>
        <!-- 开启注解配置 -->
        <context:annotation-config />
    
        <!-- 开启事务注解驱动 -->
        <tx:annotation-driven />
    
        <!-- 设置定时任务 -->
        <task:annotation-driven/>
        <context:component-scan base-package="com.nico.utils"></context:component-scan>

    然后是下面的事务管理,注解配置,定时任务等

    tx,tash需要在头文件中加入

    下面是完整的配置文件

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:context="http://www.springframework.org/schema/context"
           xmlns:tx="http://www.springframework.org/schema/tx"
           xmlns:task="http://www.springframework.org/schema/task"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-3.1.xsd
           http://www.springframework.org/schema/tx
           http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
           http://www.springframework.org/schema/task
           http://www.springframework.org/schema/task/spring-task-3.1.xsd">
    
        <!-- 自动扫描 -->
        <context:component-scan base-package="com.demaxiya.." />
    
        <!-- 引入配置文件 -->
        <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
            <property name="location" value="classpath:jdbc.properties" />
        </bean>
    
        <!-- 主数据库节点,更新写入 -->
        <bean id="Master" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
            <property name="driverClassName" value="${driver}" />
            <property name="url" value="${url_Master}" />
            <property name="username" value="${username_Master}" />
            <property name="password" value="${password_Master}" />
            <property name="initialSize" value="${initialSize}"></property>        <!-- 初始化连接大小 -->
            <property name="maxActive" value="${maxActive}"></property>            <!-- 连接池最大数量 -->
            <property name="maxIdle" value="${maxIdle}"></property>                <!-- 连接池最大空闲 -->
            <property name="minIdle" value="${minIdle}"></property>                <!-- 连接池最小空闲 -->
            <property name="maxWait" value="${maxWait}"></property>                <!-- 获取连接最大等待时间 -->
        </bean>
    
        <!-- 从数据库节点,读取 -->
        <bean id="Slave" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
            <property name="driverClassName" value="${driver}" />
            <property name="url" value="${url_Slave}" />
            <property name="username" value="${username_Slave}" />
            <property name="password" value="${password_Slave}" />
            <property name="initialSize" value="${initialSize}"></property>        <!-- 初始化连接大小 -->
            <property name="maxActive" value="${maxActive}"></property>            <!-- 连接池最大数量 -->
            <property name="maxIdle" value="${maxIdle}"></property>                <!-- 连接池最大空闲 -->
            <property name="minIdle" value="${minIdle}"></property>                <!-- 连接池最小空闲 -->
            <property name="maxWait" value="${maxWait}"></property>                <!-- 获取连接最大等待时间 -->
        </bean>
        <!-- 设置默认数据连接 -->
        <bean id="multipleDataSource" class="com.demaxiya.utils.ChangeDatabases.MultipleDataSource">
            <property name="defaultTargetDataSource" ref="Master"/>
            <property name="targetDataSources">
                <map>
                    <entry key="Master" value-ref="Master"/>
                    <entry key="Slave" value-ref="Slave"/>
                </map>
            </property>
        </bean>
        <!-- spring和MyBatis完美整合,不需要mybatis的配置映射文件 -->
        <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
            <property name="dataSource" ref="multipleDataSource" />
            <property name="configLocation" value="classpath:mybatis.xml" />
            <property name="mapperLocations" value="classpath:com/demaxiya/mapper/*.xml"></property>
        </bean>
    
        <!-- DAO接口所在包名,Spring会自动查找其下的类 -->
        <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
            <property name="basePackage" value="com.demaxiya.dao" />
            <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>
        </bean>
    
        <!-- (事务管理)transaction manager, use JtaTransactionManager for global tx -->
        <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            <!-- 只有写入时候需要开启事务 -->
            <property name="dataSource" ref="Master" />
        </bean>
    
        <!-- 开启注解配置 -->
        <context:annotation-config />
    
        <!-- 开启事务注解驱动 -->
        <tx:annotation-driven />
    
        <!-- 设置定时任务 -->
        <task:annotation-driven/>
        <context:component-scan base-package="com.demaxiya.utils"></context:component-scan>
    </beans>
    继续来配置web.xml文件让全部请求都由jersey来转发
    <servlet>
        <servlet-name>jersey-serlvet</servlet-name>
        <servlet-class>org.glassfish.jersey.servlet.ServletContainer</servlet-class>
        <init-param>
          <param-name>javax.ws.rs.Application</param-name>
          <param-value>com.demaxiya.utils.RestApplication</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
      </servlet>
      <servlet-mapping>
        <servlet-name>jersey-serlvet</servlet-name>
        <url-pattern>/*</url-pattern>
      </servlet-mapping>

    全部的web.xml文件

    <?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xmlns="http://java.sun.com/xml/ns/javaee"
             xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
             xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
             http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" version="2.5">
      <display-name>BJDR - Restful Web Application</display-name>
      <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
      </listener>
      <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring-mybatis.xml</param-value>
      </context-param>
      <servlet>
        <servlet-name>jersey-serlvet</servlet-name>
        <servlet-class>org.glassfish.jersey.servlet.ServletContainer</servlet-class>
        <init-param>
          <param-name>javax.ws.rs.Application</param-name>
          <param-value>com.demaxiya.utils.RestApplication</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
      </servlet>
      <servlet-mapping>
        <servlet-name>jersey-serlvet</servlet-name>
        <url-pattern>/*</url-pattern>
      </servlet-mapping>
    </web-app>

    其中的restapplication就是注册jersey服务的入口

    // 注册JAX-RS应用组件
        public RestApplication(){
            //服务类所在的包路径  
            packages("com.nico.service");
            
            register(RequestContextFilter.class);    // System
            register(JacksonFeature.class);            // System
            register(JacksonJsonProvider.class);    // System
            register(LoggingFilter.class);            // Log
            
        }

    注册服务。然后我们就可以正式开始写接口了

    5.建立service来提供访问地址

    下面的就是平常的建立class

    package com.demaxiya.service;
    
    import com.demaxiya.dao.AccountMapper;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    
    import javax.ws.rs.Consumes;
    import javax.ws.rs.GET;
    import javax.ws.rs.Path;
    import javax.ws.rs.Produces;
    import javax.ws.rs.core.Response;
    
    /**
     * Created by Administrator on 2016/4/18.
     */
    @Component
    @Path("accounts")
    public class AccountService {
    
        @Autowired
        private AccountMapper accountMapper;
    
    
        @GET
        @Consumes({ "application/json; charset=UTF-8", "application/xml; charset=UTF-8" })
        @Produces({ "application/json; charset=UTF-8", "application/xml; charset=UTF-8" })
        public Response getAccounts(){
            System.out.println("测试来啦!!!!");
    
            return null;
        }
    }

    然后过来访问,然后建立映射等,mapper文件。具体DEMO在下面的链接

    https://github.com/308681282/my_work

    示例代码喽。

    转载于:https://www.cnblogs.com/wuwulalala/p/5404534.html

    展开全文
  • 什么是Gradle?

    千次阅读 2016-05-14 22:47:26
    什么是Gradle? Gradle是一种依赖管理工具,基于Groovy语言,面向Java应用主,它抛弃了基于XML的各种繁琐配置,取而代之的是一种基于Groovy的内部领域特定(DSL)语言。...那么下载的Gradle到什么地方呢?

    什么是Gradle?
    Gradle是一种依赖管理工具,基于Groovy语言,面向Java应用为主,它抛弃了基于XML的各种繁琐配置,取而代之的是一种基于Groovy的内部领域特定(DSL)语言。

    安装Gradle
    在Android Studio系列教程一–下载与安装中新建项目成功后会下载Gradle,貌似这个过程不翻墙也是可以下载,但是访问特别慢,建议翻墙下载。那么下载的Gradle到什么地方呢?

    Mac上会默认下载到 /Users/<用户名>/.gradle/wrapper/dists 目录
    Win平台会默认下载到 C:\Documents and Settings\<用户名>.gradle\wrapper\dists 目录
    你会看到这个目录下有个 gradle-x.xx-all 的文件夹, 如果下载实在太慢,但是又不想翻墙的话,可以自己手动到Gradle官网下载对应的版本,然后将下载的.zip文件(也可以解压)复制到上述的gradle-x.xx-all 文件夹下,不过还是建议让它直接下载的好。

    Gradle 基本概念
    下面就以我的开源项目MyApplication 来详细讲解下和Gradle相关的知识, 和Gradle相关的几个文件一般有如下几个:

    红色标记部分从上到下咱们来一步步分析:

    1. app/build.gradle

    这个文件是app文件夹下这个Module的gradle配置文件,也可以算是整个项目最主要的gradle配置文件,我们来看下这个文件的内容:

    // 声明是Android程序
    apply plugin: ‘com.android.application’

    android {
    // 编译SDK的版本
    compileSdkVersion 21
    // build tools的版本
    buildToolsVersion “21.1.1”

    defaultConfig {
        // 应用的包名
        applicationId "me.storm.ninegag"
        minSdkVersion 14
        targetSdkVersion 21
        versionCode 1
        versionName "1.0.0"
    }
    
    // java版本
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_7
        targetCompatibility JavaVersion.VERSION_1_7
    }
    
    buildTypes {
        release {
            // 是否进行混淆
            minifyEnabled false
            // 混淆文件的位置
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.txt'
        }
    }
    
    // 移除lint检查的error
    lintOptions {
      abortOnError false
    }
    

    }

    dependencies {
    // 编译libs目录下的所有jar包
    compile fileTree(dir: ‘libs’, include: [‘*.jar’])
    compile ‘com.android.support:support-v4:21.0.2’
    compile ‘com.etsy.android.grid:library:1.0.5’
    compile ‘com.alexvasilkov:foldable-layout:1.0.1’
    // 编译extras目录下的ShimmerAndroid模块
    compile project(‘:extras:ShimmerAndroid’)
    }
    这里需要说明几点:

    文件开头apply plugin是最新gradle版本的写法,以前的写法是apply plugin: ‘android’, 如果还是以前的写法,请改正过来。
    buildToolsVersion这个需要你本地安装该版本才行,很多人导入新的第三方库,失败的原因之一是build version的版本不对,这个可以手动更改成你本地已有的版本或者打开 SDK Manager 去下载对应版本。
    applicationId代表应用的包名,也是最新的写法,这里就不在多说了。
    android 5.0开始默认安装jdk1.7才能编译,但是由于mac系统自带jdk的版本是1.6,所以需要手动下载jdk1.7并配置下,具体可以见我这篇博客Mac下安装和管理Java
    minifyEnabled也是最新的语法,很早之前是runProguard,这个也需要更新下。
    proguardFiles这部分有两段,前一部分代表系统默认的android程序的混淆文件,该文件已经包含了基本的混淆声明,免去了我们很多事,这个文件的目录在

    展开全文
  • 相关阅读:为什么要分布式 id ?分布式 id 生成方案有哪些? 分布式事务 分布式事务就是指事务的参与者、支持事务的服务器、资源服务器以及事务管理器分别位于不同的分布式系统的不同节点之上。 简单的说,就是一次...
  • 面试官:Java中提供了synchronized,为什么还要提供Lock呢? 一文搞懂PV、UV、VV、IP及其关系与计算 学好并发编程,需要掌握这些核心知识体系!! 高并发秒杀系统架构解密,不是所有的秒杀都是秒杀! 讲讲高并发场景...
  • 以上部分对工作流、BPMN、Activiti的概念做了一个简单的介绍,目的是了解Activiti究竟是什么,能做些什么…及在学习Activiti之前需要了解的知识与技术。其中大部分文字来自Copy网上的各种资料与文档,通过总结而来的...
  • 那么适合什么人群使用和学习呢? 1,Java初学者,这个是一个很好的学习框架,让你学会整体流程 2,Java有一定经验(大牛除外),但是之前做的工作一直是打下手,这个框架就比较适合了,可以让自己对框架更深的了解,...
  • 写得也是很,同样一遇到客户的业务逻辑一变,修改代码而疲于奔命。这时我除了php框架thinkphp,还想到了Spring+Struts+Hibernate等企业级的框架应用。 然后试图找来php,希望能发挥其敏捷的特性,我加快...
  • 其实服务化架构已经可以解决大部分企业的需求了,那么我们为什么要研究微服务呢?先说说它们的区别; 1、微服务架构强调业务系统需要彻底的组件化和服务化,一个组件就是一个产品,可以独立对外提供服务。 2、微服务...
  • 当网络较,网页还在加载 Vue.js ,而导致 Vue 来不及渲染,这时页面就会显示出 Vue 源代码。我们可以使用 v-cloak 指令来解决这一问题。 <div id="app" v-cloak> <h2>{{message}}</h2> </...
  • Gradle基础

    2017-08-04 19:30:07
    什么是Gradle? Gradle是一种依赖管理工具,基于Groovy语言,面向Java应用主,它抛弃了基于XML的各种繁琐配置,取而代之的是一种基于Groovy的内部领域特定(DSL)语言。...那么下载的Gradle到什么
  • Android studio————Gradle基础语法

    千次阅读 2017-01-19 11:15:30
    什么是Gradle? Gradle是一种依赖管理工具,基于Groovy语言,面向Java应用主,它抛弃了基于XML的各种繁琐配置,取而代之的是一种基于Groovy的内部领域特定(DSL)语言。...那么下载的Gradle到什么
  • 关于安卓开发工具AS(第一篇)

    千次阅读 2016-09-12 10:38:49
    什么是Gradle? Gradle是一种依赖管理工具,基于Groovy语言,面向Java应用主,它抛弃了基于XML的各种繁琐配置,取而代之的是一种基于Groovy的内部领域特定(DSL)语言。...那么下载的Gradle到什么
  • IDEA 热部署神器:JreBel

    千次阅读 2017-08-14 16:25:05
    IDEA热部署神器:JreBel为什么用热部署在用IDEA时,书写java web项目时,当我们修改java类文件时,都要重启Tomcat,在电脑配置低,启动,频繁修改项目,频繁启动Tomcat是否已经让你抓狂。那么来用JreBel吧。安装...
  • 什么是Gradle? Gradle是一种依赖管理工具,基于Groovy语言,面向Java应用主,它抛弃了基于XML的各种繁琐配置,取而代之的是一种基于Groovy的内部领域特定(DSL)语言。...那么下载的Gradle到什么...
  • 什么是Gradle? Gradle是一种依赖管理工具,基于Groovy语言,面向Java应用主,它抛弃了基于XML的各种繁琐配置,取而代之的是一种基于Groovy的内部领域特定(DSL)语言。...那么下载的Gradle到什么
  • Android studio之Gradle

    2017-03-17 17:05:38
    什么是Gradle?Gradle是一种依赖管理工具,基于Groovy语言,面向Java应用主,它抛弃了基于XML的各种繁琐配置,取而代之的是一种基于Groovy的内部领域特定(DSL)语言。...那么下载的Gradle到什么地方呢?Mac上

空空如也

空空如也

1 2 3 4
收藏数 75
精华内容 30
关键字:

为什么java下载那么慢

java 订阅