文档章节

如何写出更好的Java代码

java_T
 java_T
发布于 2014/06/05 10:56
字数 5798
阅读 358
收藏 37
点赞 0
评论 3

Java是最流行的编程语言之一,但似乎并没有人喜欢使用它。好吧,实际上Java是一门还不错的编程语言,由于最近Java 8发布了,我决定来编辑一个如何能更好地使用Java的列表,这里面包括一些库,实践技巧以及工具。

  这篇文章在GitHub上也有。你可以随时在上面贡献或者添加你自己的Java使用技巧或者最佳实践。

  • 编码风格

    • 文档

    • Stream

    • builder模式

    • 结构体

    • 依赖注入

    • 避免null值

    • 不可变

    • 避免过多的工具类

    • 格式

    • 部署

      • 依赖收敛

      • 框架

      • Maven

      • 持续集成

      • Maven仓储

      • 配置管理

      • jUnit 4

      • jMock

      • AssertJ

      • Apache Commons

      • Guava

      • Gson

      • Java Tuples

      • Joda-Time

      • Lombok

      • Play framework

      • SLF4J

      • jOOQ

      • 遗失的特性

      • 测试

      • 工具

        • Chronon

        • IntelliJ IDEA

        • JRebel

        • 校验框架

        • Eclipse Memory Analyzer

      • 资源

        • 书籍

        • 播客

        编码风格

        传统的Java编码方式是非常啰嗦的企业级JavaBean的风格。新的风格更简洁准确,对眼睛也更好。

        结构体

        我们这些码农干的最简单的事情就是传递数据了。传统的方式就是定义一个JavaBean:

      ?

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      public class DataHolder {
          private String data;
          public DataHolder() {
          }
          public void setData(String data) {
              this .data = data;
          }
          public String getData() {
              return this .data;
          }
      }

      这不仅拖沓而且浪费。尽管你的IDE可以自动地生成这个,但这还是浪费。因此,不要这么写

        相反的,我更喜欢C的结构体的风格,写出来的类只是包装数据:

      ?

      1
      2
      3
      4
      5
      6
      7
      public class DataHolder {
          public final String data;
          public DataHolder(String data) {
              this .data = data;
          }
      }

        这样写减少了一半的代码。不仅如此,除非你继承它,不然这个类是不可变的,由于它是不可变的,因此推断它的值就简单多了。

        如果你存储的是Map或者List这些可以容易被修改的数据,你可以使用ImmutableMap或者ImmutableList,这个在不可变性这节中会有讨论。

        Builder模式

        如果你有一个相对复杂的对象,可以考虑下Builder模式。

      你在对象里边创建一个子类,用来构造你的这个对象。它使用的是可修改的状态,但一旦你调用了build方法,它会生成一个不可变对象。

      想象一下我们有一个非常复杂的对象DataHolder。它的构造器看起来应该是这样的:

      ?

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      public class ComplicatedDataHolder {
          public final String data;
          public final int num;
          // lots more fields and a constructor
          public class Builder {
              private String data;
              private int num;
              public Builder data(String data) {
                  this .data = data;
                  return this ;
              }
              public Builder num( int num) {
                  this .num = num;
                  return this ;
              }
              public ComplicatedDataHolder build() {
                  return new ComplicatedDataHolder(data, num); // etc
              }  
          }
      }

        现在你可以使用它了:

      ?

      1
      2
      3
      4
      final ComplicatedDataHolder cdh = new ComplicatedDataHolder.Builder()
          .data( "set this" )
          .num( 523 )
          .build();

        关于Builder的使用这里还有些更好的例子,我这里举的例子只是想让你大概感受一下。当然这会产生许多我们希望避免的样板代码,不过好处就是你有了一个不可变对象以及一个连贯接口。

        依赖注入

        这更像是一个软件工程的章节而不是Java的,写出可测的软件的一个最佳方式就是使用依赖注入(Dependency injection,DI)。由于Java强烈鼓励使用面向对象设计 ,因此想写出可测性强的软件,你需要使用DI。

        在Java中,这个通常都是用Spring框架来完成的。它有一个基于XML配置的绑定方式,并且仍然相当流行。重要的一点是你不要因为它的基于XML的配置格式而过度使用它了。在XML中应该没有任何的逻辑和控制结构。它只应该是依赖注入。

        还有一个不错的方式是使用Dagger库以及Google的Guice。它们并没有使用Spring的XML配置文件的格式,而是将注入的逻辑放到了注解和代码里。

        避免null值

        如果有可能的话尽量避免使用null值。你可以返回一个空的集合,但不要返回null集合。如果你准备使用null的话,考虑一下@Nullable注解。IntelliJ IDEA对于@Nullable注解有内建的支持。

        如果你使用的是Java 8的话,可以考虑下新的Optional类型。如果一个值可能存在也可能不存在,把它封装到Optional类里面,就像这样:

      ?

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      public class FooWidget {
          private final String data;
          private final Optional<Bar> bar;
          public FooWidget(String data) {
              this (data, Optional.empty());
          }
          public FooWidget(String data, Optional<Bar> bar) {
              this .data = data;
              this .bar = bar;
          }
          public Optional<Bar> getBar() {
              return bar;
          }
      }

        现在问题就清楚了,data是不会为null的,而bar可能为空。Optional类有一些像isPresent这样的方法,这让它感觉跟检查null没什么区别。不过有了它你可以写出这样的语句:

      ?

      1
      2
      3
      4
      final Optional<FooWidget> fooWidget = maybeGetFooWidget();
      final Baz baz = fooWidget.flatMap(FooWidget::getBar)
                              .flatMap(BarWidget::getBaz)
                              .orElse(defaultBaz);

        这比使用if来检查null好多了。唯一的缺点就是标准类库中对Optional的支持并不是很好,因此你还是需要对null进行检查的。

        不可变

        变量,类,集合,这些都应该是不可变的,除非你有更好的理由它们的确需要进行修改。

        变量可以通过final来设置成不可变的:

      ?

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      final FooWidget fooWidget;
      if (condition()) {
          fooWidget = getWidget();
      } else {
          try {
              fooWidget = cachedFooWidget.get();
          } catch (CachingException e) {
              log.error( "Couldn't get cached value" , e);
              throw e;
          }
      }
      // fooWidget is guaranteed to be set here

        现在你可以确认fooWidget不会不小心被重新赋值了。final关键字可以和if/else块以及try/catch块配合使用。当然了,如果fooWidget对象不是不可变的,你也可以很容易地对它进行修改。

        有可能的话,集合都应该尽量使用Guava的ImmutableMap, ImmutableList, or ImmutableSet类。这些类都有自己的构造器,你可以动态的创建它们,然后将它们设置成不可变的,。

        要使一个类不可变,你可以将它的字段声明成不可变的(设置成final)。你也可以把类自身也设置成final的这样它就不能被扩展并且修改了,当然这是可选的。

        避免大量的工具类

        如果你发现自己添加了许多方法到一个Util类里,你要注意了。

      ?

      1
      2
      3
      4
      5
      6
      7
      8
      9
      public class MiscUtil {
          public static String frobnicateString(String base, int times) {
              // ... etc
          }
          public static void throwIfCondition( boolean condition, String msg) {
              // ... etc
          }
      }

        这些类乍一看挺吸引人的,因为它们里面的这些方法不属于任何一个地方。因此你以代码重用之名将它们全都扔到这里了。

        这么解决问题结果更糟。把它们放回它们原本属于的地方吧,如果你确实有一些类似的常用方法,考虑下Java 8里接口的默认方法。并且由于它们是接口,你可以实现多个方法。

      ?

      1
      2
      3
      4
      5
      6
      7
      8
      9
      public interface Thrower {
          public void throwIfCondition( boolean condition, String msg) {
              // ...
          }
          public void throwAorB(Throwable a, Throwable b, boolean throwA) {
              // ...
          }
      }

        这样需要使用它的类只需简单的实现下这个接口就可以了。

        格式

        格式远比许多程序员相像的要重要的多。一致的格式说明你关注自己的代码或者对别人有所帮助?是的。不过你先不要着急为了让代码整齐点而浪费一整天的时间在那给if块加空格了。

        如果你确实需要一份代码格式规范,我强烈推荐Google的Java风格指南。这份指南最精彩的部分就是编程实践这节了。非常值得一读。

        文档

        面向用户的代码编写下文档还是很重要的。这意味着你需要提供一些使用的示例,同时你的变量方法和类名都应该有适当的描述信息。

        结论就是不要给不需要文档的地方添加文档。如果对于某个参数你没什么可说的,或者它已经非常明显了,别写文档了。模板化的文档比没有文档更糟糕,因为它欺骗了你的用户,让他觉得这里有文档。

        流

        Java 8有一个漂亮的流和lambda表达式的语法。你的代码可以这么写:

      ?

      1
      2
      3
      final List<String> filtered = list.stream()
          .filter(s -> s.startsWith( "s" ))
          .map(s -> s.toUpperCase());

        而不是这样:

      ?

      1
      2
      3
      4
      5
      6
      final List<String> filtered = Lists.newArrayList();
      for (String str : list) {
          if (str.startsWith( "s" ) {
              filtered.add(str.toUpperCase());
          }
      }

        这样你能写出更连贯的代码,可读性也更强。

        部署

        正确地部署Java程序还是需要点技巧的。现在部署Java代码的主流方式有两种 :使用框架或者使用自家摸索出来的解决方案,当然那样更灵活。

        框架

        由于部署Java程序并不容易,因此才有了各种框架来用于部署。最好的两个是Dropwizard以及Spring BootPlay Framework也可以算是一个部署框架。

        这些框架都试图降低部署程序的门槛。如果你是一个Java的新手或者你需要快速把事情搞定的话,那么框架就派上用场了。单个jar的部署当然会比复杂的WAR或者EAR部署要更容易一些。

        然而,这些框架的灵活性不够,并且相当顽固,因此如果这些框架的开发人员给出的方式不太适合你的项目的话,你只能自己进行配置了。

        Maven

        备选方案:Gradle

        Maven仍然是编译,打包,运行测试的标准化工具。还有其它一些选择,比如Gradle,不过它们的采用程度远不Maven。如果你之前没用过Maven,你可以看下这个Maven的使用示例

        我喜欢用一个根POM文件来包含所有的外部依赖。它看起来就像是这样。这个根POM文件只有一个外部依赖,不过如果你的产品很大的话,你可能会有很多依赖。你的根POM文件自己就应该是一个项目:它有版本控制,并且和其它的Java项目一样进行发布。

        如果你觉得为每个外部依赖的修改都给POM文件打个标签(tag)有点太浪费了,那是你还没有经历过花了一个星期的时间来跟踪项目依赖错误的问题。

        你的所有Maven工程都应该包含你的主POM文件以及所有的版本信息。这样的话,你能知道公司项目的每个外部依赖所选择的版本,以及所有正确的Maven插件。如果你需要引入一个外部依赖的话,大概是这样的:

      ?

      1
      2
      3
      4
      5
      6
      <dependencies>
          <dependency>
              <groupId>org.third.party</groupId>
              <artifactId>some-artifact</artifactId>
          </dependency>
      </dependencies>

        如果你需要进行内部依赖的话,应该在项目的段中单独进行维护。不然的话,主POM文件的版本号就要疯涨了。

        依赖收敛

        Java的一个最好的地方就是有大量的第三方库,它们无所不能。几乎每个API或者工具都有相应的Java SDK,并且可以很容易地引入到Maven中来。

        所有的这些Java库自身可能又会依赖一些特定的版本的其它类库。如果你引入了大量的库,可能会出现版本冲突 ,比如说像这样:

      ?

      1
      2
      Foo library depends on Bar library v1. 0
      Widget library depends on Bar library v0. 9

        你的工程应该引入哪个版本?

        有了Maven的依赖收敛的插件后,如果你的依赖版本不一致的话,编译的时候就会报错。那么你有两种解决冲突的方案:

      • 在dependencyManagement区中显式地选择某个版本的bar。

      • Foo或者Widget都不要依赖Bar。

        到底选择哪种方案取决你的具体情况: 如果你想要跟踪某个工程的版本,不依赖它是最好的。另一方面,如果你想要明确一点,你可以自己选择一个版本,不过这样的话,如果更新了其它的依赖,也得同步地修改它。

        持续集成

        很明显你需要某种持续集成的服务器来不断地编译你的SNAPSHOT版本,或者对Git分支进行构建。

        JenkinsTravis-CI是你的不二选择。

        代码覆盖率也很重要,Cobertura有一个不错的Maven插件,并且对CI支持的也不错。当然还有其它的代码覆盖的工具,不过我用的是Cobertura。

        Maven库

        你需要一个地方来存储你编译好的jar包,war包,以及EAR包,因此你需要一个代码仓库。

        常见的选择是Artifactory或者Nexus。两个都能用,并且各有利弊。

        你应该自己进行Artifactory/Nexus的安装并且将你的依赖做一份镜像。这样不会由于下载Maven 库的时候出错了导到编译中断。

        配置管理

        那现在你的代码可以编译了,仓库也搭建起来了,你需要把你的代码带出开发环境,走向最终的发布了。别马虎了,因为自动化执行从长远来看,好处是大大的。

        ChefPuppet,和Ansible都是常见的选择。我自己也写了一个可选方案,Squadron。这个嘛,当然了,我自然是希望你们能下载下它的,因为它比其它那些要好用多了。

        不管你用的是哪个工具,别忘了自动化部署就好。

        库

        可能Java最好的特性就是它拥有的这些库了。下面列出了一些库,应该绝大多数人都会用得上。

        Java的标准库,曾经还是很不错的,但在现在看来它也遗漏掉了很多关键的特性。

        Apache Commons

        Apache Commons项目有许多有用的功能。

      • Commons Codec有许多有用的Base64或者16进制字符串的编解码的方法。别浪费时间自己又写一遍了。

      • Commons Lang是一个字符串操作,创建,字符集,以及许多工具方法的类库。

      • Commons IO,你想要的文件相关的方法都在这里了。它有FileUtils.copyDirectory,FileUtils.writeStringToFile, IOUtils.readLines,等等。

        Guava

        Guava是一个非常棒的库,它就是Java标准库"所缺失的那部分"。它有很多我喜欢的地方,很难一一赘述,不过我还是想试一下。

      • Cache,这是一个最简单的获取内存缓存的方式了,你可以用它来缓存网络访问,磁盘访问,或者几乎所有东西。你只需实现一个CacheBuilder,告诉Guava如何创建缓存就好了。

      • 不可变集合。这里有许多类:ImmutableMap, ImmutableList,甚至还有ImmutableSortedMultiSet,如果这就是你想要的话。

        我还喜欢用Guava的方式来新建可变集合:

      ?

      1
      2
      3
      4
      5
      // Instead of
      final Map<String, Widget> map = new HashMap<String, Widget>();
      // You can use
      final Map<String, Widget> map = Maps.newHashMap();

        有许多像Lists, Maps, Sets的静态类,他们都更简洁易懂一些。

        如果你还在坚持使用Java 6或者7的话,你可以用下Collections2,它有一些诸如filter和transform的方法。没有Jvaa 8的stream的支持,你也可以用它们来写出连贯的代码。

        Guava也有一些很简单的东西,比如Joiner,你可以用它来拼接字符串,还有一个类可以用来处理中断

        Gson

        Google的Gson是一个简单高效的JSON解析库。它是这样工作的:

      ?

      1
      2
      3
      4
      final Gson gson = new Gson();
      final String json = gson.toJson(fooWidget);
      final FooWidget newFooWidget = gson.fromJson(json, FooWidget. class );

        真的很简单,使用它会感觉非常愉快。Gson的用户指南中有更多的示例。

        Java Tuples

        我对Java一个不爽的地方就是它的标准库中居然没有元组。幸运的是, Java tuples工程解决了这一问题。

        它也很容易使用,并且真的很赞:

      ?

      1
      2
      3
      4
      Pair<String, Integer> func(String input) {
          // something...
          return Pair.with(stringResult, intResult);
      }

        Joda-Time

        Joda-Time是我用过的最好的时间库了。简直,直接,容易测试。你还想要什么?

        这个库里我最喜欢的一个类就是Duration,因为我用它来告诉说我要等待多长时间,或者过多久我才进行重试。

        Lombok

        Lombok是一个非常有趣的库。它通过注释来减少了Java中的饱受诟病的样板代码(注:setter,getter之类的)。

        想给你类中的变量增加setter, getter方法?太简单了:

      ?

      1
      2
      3
      public class Foo {
          @Getter @Setter private int var;
      }

        现在你可以这么写了:

      ?

      1
      2
      final Foo foo = new Foo();
      foo.setVar( 5 );

        这里还有更多的示例。我还没在生产代码中用过Lombok,不过我有点等不及了。

      Play框架

        备选方案:Jersey或者Spark

        在Java中实现REST风格的WEB服务有两大阵营:JAX-RS和其它。

        JAX-RS是传统的方式。你使用像Jersey这样的东西来将注解和接口,实现组合到一起来实现WEB服务。这样做的好处就是,你可以通过一个接口就能很容易创建出一个调用的客户端来。

        Play框架是在JVM上实现WEB服务的截然不同的一种方式:你有一个routes文件,然后你去实现routes中那些规则所引用到的类。它其实就是个完整的MVC框架,不过你可以只用它来实现REST服务。

        它同时支持Java和Scala。它优先使用Scala这点可能有点令人沮丧,但是用Java进行开发的话也非常不错。

        如果你习惯了Python里的Flask这类的微框架,那么你应该会对Spark感到很熟悉。有了Java 8它简直如虎添翼。

        SLF4J

        Java打印日志有许多不错的解决方案。我个人最喜欢的是SLF4J,因为它是可挺插拔的,并且可以同时混合不同的日志框架中输出的日志。有个奇怪的工程同时使用了java.util.logging, JCL, 和log4j?没问题,SLF4J就是为它而生的。

        想入门的话,看下它的这个两页的手册就足够的了。

        jOOQ

        我不喜欢很重的ORM框架,因为我喜欢SQL。因此我写了许多的JDBC模板,但它们很难维护。jOOQ是个更不错的解决方案。

        你可以在Java中以一种类型安全的方式来书写SQL语句:

      ?

      1
      2
      3
      4
      5
      6
      7
      8
      // Typesafely execute the SQL statement directly with jOOQ
      Result<Record3<String, String, String>> result =  
      create.select(BOOK.TITLE, AUTHOR.FIRST_NAME, AUTHOR.LAST_NAME)
          .from(BOOK)
          .join(AUTHOR)
          .on(BOOK.AUTHOR_ID.equal(AUTHOR.ID))
          .where(BOOK.PUBLISHED_IN.equal( 1948 ))
          .fetch();

        将它以及DAO模式结合起来,你可以让数据库访问变得更简单。

        测试

        测试对软件来说至关重要。下面这些库能让测试变得更加容易。

        jUnit 4

        jUnit就不用介绍了。它是Java中单元测试的标准工具。

        不过可能你还没有完全发挥jUnit的威力。jUnit还支持参数化测试,以及能让你少写很多样板代码的测试规则,还有能随机测试代码的Theory,以及Assumptions

        jMock

        如果你已经完成了依赖注入,那么它回报你的时候来了:你可以mock出带副作用的代码(就像和REST服务器通信那样),并且仍然能对调用它的代码执行断言操作。

        jMock是Java中标准的mock工具。它的使用方式是这样的:

      ?

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      public class FooWidgetTest {
          private Mockery context = new Mockery();
          @Test
          public void basicTest() {
              final FooWidgetDependency dep = context.mock(FooWidgetDependency. class );
              context.checking( new Expectations() {
                  oneOf(dep).call(with(any(String. class )));
                  atLeast( 0 ).of(dep).optionalCall();
              });
              final FooWidget foo = new FooWidget(dep);
              Assert.assertTrue(foo.doThing());
              context.assertIsSatisfied();
          }
      }

        这段代码通过jMock设置了一个FooWidgetDependency ,然后添加了一些期望的操作。我们希望dep的call方法被调用一次而dep的optionalCall 方法会被调用0或更多次。

        如果你反复的构造同样的FooWidgetDependency,你应该把它放到一个测试设备(Test Fixture)里,然后把assertIsSatisfied放到一个@After方法中。

        AssertJ

        你是不是用jUnit写过这些?

      ?

      1
      2
      3
      4
      5
      final List<String> result = some.testMethod();
      assertEquals( 4 , result.size());
      assertTrue(result.contains( "some result" ));
      assertTrue(result.contains( "some other result" ));
      assertFalse(result.contains( "shouldn't be here" ));

        这些样板代码有点太聒噪了。AssertJ解决了这个问题。同样的代码可以变成这样:

      ?

      1
      2
      3
      assertThat(some.testMethod()).hasSize( 4 )
                                  .contains( "some result" , "some other result" )
                                  .doesNotContain( "shouldn't be here" );

        连贯接口让你的测试代码可读性更强了。代码如此,夫复何求?

        工具

        IntelliJ IDEA

        备选方案: Eclipse and Netbeans

        最好的Java IDE当然是 IntelliJ IDEA。它有许多很棒的特性,我们之所以还能忍受Java这些冗长的代码,它起了很大的作用。自动补全很棒,< a href="http://i.imgur.com/92ztcCd.png" target="_blank">代码检查也超赞,重构工具也非常实用。

        免费的社区版对我来说已经足够了,不过在旗舰版中有许多不错的特性比如数据库工具,Srping框架的支持以及Chronon等。

        Chronon

        GDB 7中我最喜欢的特性就是调试的时候可以按时间进行遍历了。有了IntelliJ IDEA的Chronon插件后,这个也成为现实了。当然你得是旗舰版的。

        你可以获取到变量的历史值,跳回前面执行的地方,获取方法的调用历史等等。第一次使用的话会感觉有点怪,但它能帮忙你调试一些很棘手的BUG。

        JRebel

        持续集成通常都是SaaS产品的一个目标。你想想如果你甚至都不需要等到编译完成就可以看到代码的更新?

        这就是JRebel在做的事情。只要你把你的服务器挂到某个JRebel客户端上,代码一旦有改动你马上就能看到效果。当你想快速体验一个功能的话,这个的确能节省不少时间。

        验证框架

        Java的类型系统是相当弱的。它不能区分出普通字符串以及实际上是正则的字符串,也不能进行

      ?

      1
      2
      3
      4
      5
      6
      7
      8
      $ jmap -dump:live,format=b,file=heapdump.hprof -F 8152
      Attaching to process ID 8152 , please wait...
      Debugger attached successfully.
      Server compiler detected.
      JVM version is 23.25 -b01
      Dumping heap to heapdump.hprof ...
      ... snip ...
      Heap dump file created

        然后你就可以用Memory Analyzer来打开heapdump.hprof文件,看看到底发生了什么。

        资源

        好的资源能帮助你成为一名Java大师。

        书籍

        播客

        The Java Posse


      本文转载自:http://www.admin10000.com/document/4438.html

      共有 人打赏支持
      java_T

      java_T

      粉丝 32
      博文 71
      码字总数 13017
      作品 0
      深圳
      高级程序员
      加载中

      评论(3)

      firefoxmmx
      firefoxmmx
      这个就是似乎说的函数式的方式吧。讲究多使用不可变的变量,这样可以避免线程并发的问题。不过这些内容都应该是scala 或者haskll之类的标准法则。
      java_T
      java_T

      引用来自“许雷神”的评论

      大福利呀,谢谢
      好东西,值得分享,呵呵
      许雷神
      许雷神
      大福利呀,谢谢
      Java 8里面lambda的最佳实践

      Java 8已经推出一段时间了,越来越多开发人员选择升级JDK,这条热门动弹里面看出,JDK7最多,其次是6和8,这是好事! 在8 里面Lambda是最火的主题,不仅仅是因为语法的改变,更重要的是带来了...

      OSC闲人
      2015/04/30
      0
      41
      【实例教程】Echarts 的 Java 封装类库

      Echarts 的 Java 封装类库:[http://www.oschina.net/p/echarts-java][1] 没想到喜欢Echarts 的 Java 封装类库的人还挺多,在源码中的测试例子一般目的只是构造官网例子的结构,这里写个比较...

      Liuzh_533
      2014/09/22
      0
      30
      高手问答第 204 期 —— Java EE 开发专家教你用 Spring Boot 2 高效开发企业应用

      OSCHINA 本期高手问答(2018 年 7 月 10 日 — 7 月 16 日)我们请来了@肖文吉 为大家解答关于 Spring Boot 2 方面的问题。 肖文吉,Java EE 应用开发专家,疯狂 Java 团队精英讲师。15年以上软...

      局长
      07/09
      0
      0
      书单丨5本Java后端技术书指引你快速进阶

      一名Java开发工程师 不仅要对Java语言及特性有深层次的理解 而且需要掌握与Java相关的 框架、生态及后端开发知识 本文涉及多种后端开发需要掌握的技能 对于帮助提高开发能力非常有帮助 NO.1...

      Java高级架构
      05/30
      0
      0
      Android Java 程序员必备开发工具

      对于Java,有两种截然不同的观点:一种认为Java是最简单功能最强大的编程语言之一,另一种则表示这种编程语言既难用又复杂。 下面这些工具或许功能和作用不同,但是有着一个共同的主旨,那就...

      拉偶有所依
      2015/06/11
      0
      1
      深入理解Java中的final关键字

      Java中的final关键字非常重要,它可以应用于类、方法以及变量。这篇文章中我将带你看看什么是final关键字?将变量,方法和类声明为final代表了什么?使用final的好处是什么?最后也有一些使用...

      longbadx
      2014/01/07
      0
      2
      深入ThreadLocal的内部机制

      早在JDK 1.2的版本中就提供java.lang.ThreadLocal,ThreadLocal为解决多线程程序的并发问题提供了一种新的思路。使用这个工具类可以很简洁地编写出优美的多线程程序。ThreadLocal并不是一个T...

      yqbboy
      2012/10/27
      0
      0
      Java开发人员需知的十大面向对象设计原则

      面向对象设计原则是OOPS(Object-Oriented Programming System,面向对象的程序设计系统)编程的核心,但大多数Java程序设计人员不重视面向对象的分析和设计。甚至还有经验丰富的Java程序员没...

      飓风2000
      2014/06/21
      0
      0
      用 JNI 进行 Java 编程(4)

      高级主题 概述 从 Java 程序内调用本机代码破坏了 Java 程序的可移植性和安全性。尽管已编译的 Java 字节码保持了很好的可移植性,但必须为您打算用来运行该应用程序的每个平台重新编译本机代...

      Jerikc
      2012/10/08
      0
      0
      Hibernate框架(一)——总体介绍

      作为SSH三大框架之一的Hibernate,是用来把程序的Dao层和数据库打交道用的,它封装了JDBC的步骤,是我们对数据库的操作更加简单,更加快捷。利用Hibernate框架我们就可以不再编写重复的JDBC代...

      凡尘里的一根葱
      2015/11/10
      0
      0

      没有更多内容

      加载失败,请刷新页面

      加载更多

      下一页

      1.14 救援模式

      确保开机启动时连接镜像文件,如果是真机服务器,就需要:U盘或光盘镜像启动进入BIOS 不同主板进入bios按键不同,一般是F12或Esc 光标:移动到Boot(开机启动项) 减号移动:光标选中行,按-...

      小丑鱼00
      11分钟前
      0
      0
      ES11-全文检索

      高级别全文检索通常用于在全文本字段(如电子邮件正文)上运行全文检索。 他们了解如何分析被查询的字段,并在执行之前将每个字段的分析器(或search_analyzer)应用于查询字符串。 1.term查...

      贾峰uk
      14分钟前
      0
      0
      java 复制对象有哪些方式

      java 复制对象有哪些方式 Apache的 Common beanutils库 org.apache.commons.beanutils.BeanUtils.copyProperties(dest,origin); Springframework 的BeanUtil 依赖: <dependency> ......

      黄威
      30分钟前
      1
      0
      jstack的简单使用

      公司测试反应, 一个java应用的机器, 即使不做交易, cpu始终是30%多, 于是想到了jstack, 实践步骤记录一下: 1, 找出java应用的进程号 ps -ef|grep 应用名|grep -v grep 2, 找出pid下的cpu占用...

      零二一七
      37分钟前
      1
      0
      崛起于Springboot2.X之项目war打包部署(18)

      将springboot项目打包步骤: 1、启动类 extends SpringBootServletInitializer 2、启动类添加覆盖方法 @Overrideprotected SpringApplicationBuilder configure(SpringApplicationBuilder......

      木九天
      46分钟前
      2
      0
      导入CSV文件就行数据整理分析

      #-*-coding:utf-8-*-import csv,os,re,mathlocalPath=input("请输入所有群文件的根目录:") #所有QQ群文件的物理根目录路径def info(): info_dic=[] dirList=os.listdi...

      Kefy
      51分钟前
      5
      0
      CoreText进阶(六)-内容大小计算和自动布局

      CoreText进阶(六)-内容大小计算和自动布局 其它文章: CoreText 入门(一)-文本绘制 CoreText入门(二)-绘制图片 CoreText进阶(三)-事件处理 CoreText进阶(四)-文字行数限制和显示更...

      aron1992
      53分钟前
      1
      0
      一个Unity高人的博客,涉猎范围很广,深度也很深。

      https://blog.csdn.net/ecidevilin/article/list/

      爽歪歪ES
      55分钟前
      0
      0
      Spring Cloud Config-Git后端

      EnvironmentRepository的默认实现使用Git后端,这对于管理升级和物理环境以及审核更改非常方便。要更改存储库的位置,可以在Config Server中设置“spring.cloud.config.server.git.uri”配置...

      itcloud
      57分钟前
      1
      0
      centos7 卸载mysql

      [root@zyf ~]# rpm -qa|grep -i mysqlmysql-community-libs-5.6.34-2.el7.x86_64mysql-community-server-5.6.34-2.el7.x86_64mysql-community-release-el7-5.noarchmysql-community-......

      Yao--靠自己
      今天
      0
      0

      没有更多内容

      加载失败,请刷新页面

      加载更多

      下一页

      返回顶部
      顶部