当前位置：主页 > 编程问答 > Java框架学习顺序

Java框架学习顺序是什么

  • 更新时间：2021-10-07 10:35:24
  • 编辑：吴伟懋
这是一篇关于java相关的编程问答内容，被186位程序员关注，内容涉及到Java零基础如何学Java、零基础Java视频教程、Java学习资料、Java框架学习顺序等，由文英悟编辑补充，一起来看下大家的回答。我们把答案参考的资料分享在下方，想深入学习的读者们可以下载学习下。
  • 参考资料

Java框架学习顺序

Java编程是世界第一编程语言，这已经达成共识，是毋庸置疑的真理，Java框架是程序员们必学的知识点，而且是十分重要的应用，Spring、Struts、Hibernate也是经典中的经典，最常用的框架类型。

作为Java零基础如何学Java呢？小编搜集了很多网友的建议，现在为大家总结如下：

对于Spring来说，最应该学习的就是Spring的IOC原理，这在使用过程中是必须要理解的、必会的。用配置文件或者是Annonation的方式来代替New创建实例，可以说这是一个历史性的进步，并且前进了一大步，影响深远，也是间接的促成了接口实现分离的优雅风格。

从配置文件开始，理解三个字母各自是如何工作的，以及是如何协同工作的。我从零开始学ssi的时候就这么干的，花了一个月左右，使用起来就比较熟练了。然后深入框架的一些高级用法，再接着琢磨它们的原理、思想和设计、实现，最后到能自己重新发明轮子。

Java新手应该如何去学习，详细步骤具体如下：

1.Java语法，可以看码农之家IT培训的零基础Java视频教程学习。

2.servlet，jsp，jdbc，结合html，css，js实现自己想要的小网站，功能慢慢积少成多。

3.spring，springmvc，springdata，hibernate等框架学习，一上来用这些框架忽略基础，这样会出现只会用xxx框架，换个yyy框架又得重新学习的感觉。

4.设计模式，aop，oop等的学习，当然可以和之前的步骤反复来研究提高，如果你想更加系统的学习Java编程，可以到码农之家官官网视频页面，里面有大量的Java学习资料可以下载。

对于具体的操作，这里也有很多小妙招：其实不外乎实操这一真理，就是亲自去写一些框架，实践出真知，只有实际操作过了才能真正理解那些曾经学过的知识都是怎么回事，比如写一些通过JDBC直接到数据库读写数据的代码，写一个简单的webapp，可以登记用户，要对数据有效性能控制，要能检测错误，然后再想办法优化成spring,hibernate和struts，优化到代码越少越好，实操之后最重要的就是思考，每做完一个项目就做一次总结，动脑多想想为什么、接下来怎么做，那么框架那点事儿就不叫事儿了。

以上就是为大家总结的关于学习三大框架的一些技巧和方法，尤其对于初学者最为重要，还是那句话，学得再多不如一次实操，边学边练是永远不变的真理，也只有这样才能真正的学到东西，才能真正的把知识转化为技能从而转化为自己的财富。

希望所有Java初学者都能顺利入门，真正掌握一门技能。

{dede:field.id function=
精选回答2：手把手教你从零设计一个java日志框架

编辑：茹松月

输出内容 - LoggingEvent

提到日志框架，最容易想到的核心功能，那就是输出日志了。那么对于一行日志内容来说，应该至少包含以下几个信息：

  • 日志时间戳
  • 线程信息
  • 日志名称（一般是全类名）
  • 日志级别
  • 日志主体（需要输出的内容，比如info（str））

为了方便的管理输出内容，现在需要创建一个输出内容的类来封装这些信息：

public class LoggingEvent {
 public long timestamp;//日志时间戳
 private int level;//日志级别
 private Object message;//日志主题
 private String threadName;//线程名称
 private long threadId;//线程id
 private String loggerName;//日志名称
 
 //getter and setters...
 
 @Override
 public String toString() {
  return "LoggingEvent{" +
    "timestamp=" + timestamp +
    ", level=" + level +
    ", message=" + message +
    ", threadName='" + threadName + '\'' +
    ", threadId=" + threadId +
    ", loggerName='" + loggerName + '\'' +
    '}';
 }
}

对于每一次日志打印，应该属于一次输出的“事件-Event”，所以这里命名为LoggingEvent

输出组件 - Appender

有了输出内容之后，现在需要考虑输出方式。输出的方式可以有很多：标准输出/控制台（Standard Output/Console）、文件（File）、邮件（Email）、甚至是消息队列（MQ）和数据库。

现在将输出功能抽象成一个组件“输出器” - Appender，这个Appender组件的核心功能就是输出，下面是Appender的实现代码：

public interface Appender {
 void append(LoggingEvent event);
}

不同的输出方式，只需要实现Appender接口做不同的实现即可，比如ConsoleAppender - 输出至控制台

public class ConsoleAppender implements Appender {
 private OutputStream out = System.out;
 private OutputStream out_err = System.err;

 @Override
 public void append(LoggingEvent event) {
  try {
   out.write(event.toString().getBytes(encoding));
  } catch (IOException e) {
   e.printStackTrace();
  }
 }
}

日志级别设计 - Level

日志框架还应该提供日志级别的功能，程序在使用时可以打印不同级别的日志，还可以根据日志级别来调整那些日志可以显示，一般日志级别会定义为以下几种，级别从左到右排序，只有大于等于某级别的LoggingEvent才会进行输出

ERROR > WARN > INFO > DEBUG > TRACE
现在来创建一个日志级别的枚举，只有两个属性，一个级别名称，一个级别数值（方便做比较）

public enum Level {
 ERROR(40000, "ERROR"), WARN(30000, "WARN"), INFO(20000, "INFO"), DEBUG(10000, "DEBUG"), TRACE(5000, "TRACE");

 private int levelInt;
 private String levelStr;

 Level(int i, String s) {
  levelInt = i;
  levelStr = s;
 }

 public static Level parse(String level) {
  return valueOf(level.toUpperCase());
 }

 public int toInt() {
  return levelInt;
 }

 public String toString() {
  return levelStr;
 }

 public boolean isGreaterOrEqual(Level level) {
  return levelInt>=level.toInt();
 }

}

日志级别定义完成之后，再将LoggingEvent中的日志级别替换为这个Level枚举

public class LoggingEvent {
 public long timestamp;//日志时间戳
 private Level level;//替换后的日志级别
 private Object message;//日志主题
 private String threadName;//线程名称
 private long threadId;//线程id
 private String loggerName;//日志名称
 
 //getter and setters...
}

现在基本的输出方式和输出内容都已经基本完成，下一步需要设计日志打印的入口，毕竟有入口才能打印嘛

日志打印入口 - Logger

现在来考虑日志打印入口如何设计，作为一个日志打印的入口，需要包含以下核心功能：

  • 提供error/warn/info/debug/trace几个打印的方法
  • 拥有一个name属性，用于区分不同的logger
  • 调用appender输出日志
  • 拥有自己的专属级别（比如自身级别为INFO，那么只有INFO/WARN/ERROR才可以输出）

先来简单创建一个Logger接口，方便扩展

public interface Logger{
 void trace(String msg);
 void info(String msg);
 void debug(String msg);
 void warn(String msg);
 void error(String msg);
 String getName();
}

再创建一个默认的Logger实现类：

public class LogcLogger implements Logger{
 private String name;
 private Appender appender;
 private Level level = Level.TRACE;//当前Logger的级别，默认最低
 private int effectiveLevelInt;//冗余级别字段，方便使用
 
 @Override
 public void trace(String msg) {
  filterAndLog(Level.TRACE,msg);
 }

 @Override
 public void info(String msg) {
  filterAndLog(Level.INFO,msg);
 }

 @Override
 public void debug(String msg) {
  filterAndLog(Level.DEBUG,msg);
 }

 @Override
 public void warn(String msg) {
  filterAndLog(Level.WARN,msg);
 }

 @Override
 public void error(String msg) {
  filterAndLog(Level.ERROR,msg);
 }
 
 /**
  * 过滤并输出，所有的输出方法都会调用此方法
  * @param level 日志级别
  * @param msg 输出内容
  */
 private void filterAndLog(Level level,String msg){
  LoggingEvent e = new LoggingEvent(level, msg,getName());
  //目标的日志级别大于当前级别才可以输出
  if(level.toInt() >= effectiveLevelInt){
   appender.append(e);
  }
 }
 
 @Override
 public String getName() {
  return name;
 }
 
 //getters and setters...
}

好了，到现在为止，现在已经完成了一个最最最基本的日志模型，可以创建Logger，输出不同级别的日志。不过显然还不太够，还是缺少一些核心功能

日志层级 - Hierarchy

一般在使用日志框架时，有一个很基本的需求：不同包名的日志使用不同的输出方式，或者不同包名下类的日志使用不同的日志级别，比如我想让框架相关的DEBUG日志输出，便于调试，其他默认用INFO级别。

而且在使用时并不希望每次创建Logger都引用一个Appender，这样也太不友好了；最好是直接使用一个全局的Logger配置，同时还支持特殊配置的Logger，且这个配置需要让程序中创建Logger时无感（比如LoggerFactory.getLogger(XXX.class)）

可上面现有的设计可无法满足这个需求，需要稍加改造

现在设计一个层级结构，每一个Logger拥有一个Parent Logger，在filterAndLog时优先使用自己的Appender，如果自己没有Appender，那么就向上调用父类的appnder，有点反向“双亲委派（parents delegate）”的意思

上图中的Root Logger，就是全局默认的Logger，默认情况下它是所有Logger（新创建的）的Parent Logger。所以在filterAndLog时，默认都会使用Root Logger的appender和level来进行输出

现在将filterAndLog方法调整一下，增加向上调用的逻辑：

private LogcLogger parent;//先给增加一个parent属性

private void filterAndLog(Level level,String msg){
 LoggingEvent e = new LoggingEvent(level, msg,getName());
 //循环向上查找可用的logger进行输出
 for (LogcLogger l = this;l != null;l = l.parent){
  if(l.appender == null){
   continue;
  }
  if(level.toInt()>effectiveLevelInt){
   l.appender.append(e);
  }
  break;
 }
}

好了，现在这个日志层级的设计已经完成了，不过上面提到不同包名使用不同的logger配置，还没有做到，包名和logger如何实现对应呢？

其实很简单，只需要为每个包名的配置单独定义一个全局Logger，在解析包名配置时直接为不同的包名

日志上下文 - LoggerContext

考虑到有一些全局的Logger，和Root Logger需要被各种Logger引用，所以得设计一个Logger容器，用来存储这些Logger

/**
 * 一个全局的上下文对象
 */
public class LoggerContext {

 /**
  * 根logger
  */
 private Logger root;

 /**
  * logger缓存，存放解析配置文件后生成的logger对象，以及通过程序手动创建的logger对象
  */
 private Map<String,Logger> loggerCache = new HashMap<>();

 public void addLogger(String name,Logger logger){
  loggerCache.put(name,logger);
 }

 public void addLogger(Logger logger){
  loggerCache.put(logger.getName(),logger);
 }
 //getters and setters...
}

有了存放Logger对象们的容器，下一步可以考虑创建Logger了

日志创建 - LoggerFactory

为了方便的构建Logger的层级结构，每次new可不太友好，现在创建一个LoggerFactory接口

public interface ILoggerFactory {
 //通过class获取/创建logger
 Logger getLogger(Class<?> clazz);
 //通过name获取/创建logger
 Logger getLogger(String name);
 //通过name创建logger
 Logger newLogger(String name);
}

再来一个默认的实现类

public class StaticLoggerFactory implements ILoggerFactory {

 private LoggerContext loggerContext;//引用LoggerContext

 @Override
 public Logger getLogger(Class<?> clazz) {
  return getLogger(clazz.getName());
 }

 @Override
 public Logger getLogger(String name) {
  Logger logger = loggerContext.getLoggerCache().get(name);
  if(logger == null){
   logger = newLogger(name);
  }
  return logger;
 }
 
 /**
  * 创建Logger对象
  * 匹配logger name，拆分类名后和已创建（包括配置的）的Logger进行匹配
  * 比如当前name为com.aaa.bbb.ccc.XXService，那么name为com/com.aaa/com.aaa.bbb/com.aaa.bbb.ccc
  * 的logger都可以作为parent logger，不过这里需要顺序拆分，优先匹配“最近的”
  * 在这个例子里就会优先匹配com.aaa.bbb.ccc这个logger，作为自己的parent
  *
  * 如果没有任何一个logger匹配，那么就使用root logger作为自己的parent
  *
  * @param name Logger name
  */
 @Override
 public Logger newLogger(String name) {
  LogcLogger logger = new LogcLogger();
  logger.setName(name);
  Logger parent = null;
  //拆分包名，向上查找parent logger
  for (int i = name.lastIndexOf("."); i >= 0; i = name.lastIndexOf(".",i-1)) {
   String parentName = name.substring(0,i);
   parent = loggerContext.getLoggerCache().get(parentName);
   if(parent != null){
    break;
   }
  }
  if(parent == null){
   parent = loggerContext.getRoot();
  }
  logger.setParent(parent);
  logger.setLoggerContext(loggerContext);
  return logger;
 }
}

再来一个静态工厂类，方便使用：

public class LoggerFactory {

 private static ILoggerFactory loggerFactory = new StaticLoggerFactory();

 public static ILoggerFactory getLoggerFactory(){
  return loggerFactory;
 }

 public static Logger getLogger(Class<?> clazz){
  return getLoggerFactory().getLogger(clazz);
 }

 public static Logger getLogger(String name){
  return getLoggerFactory().getLogger(name);
 }
}

至此，所有基本组件已经完成，剩下的就是装配了

配置文件设计

配置文件需至少需要有以下几个配置功能：

  • 配置Appender
  • 配置Logger
  • 配置Root Logger

下面是一份最小配置的示例

<configuration>

 <appender name="std_plain" class="cc.leevi.common.logc.appender.ConsoleAppender">
 </appender>

 <logger name="cc.leevi.common.logc">
  <appender-ref ref="std_plain"/>
 </logger>

 <root level="trace">
  <appender-ref ref="std_pattern"/>
 </root>
</configuration>

除了XML配置，还可以考虑增加YAML/Properties等形式的配置文件，所以这里需要将解析配置文件的功能抽象一下，设计一个Configurator接口，用于解析配置文件：

public interface Configurator {
 void doConfigure();
}

再创建一个默认的XML形式的配置解析器：

public class XMLConfigurator implements Configurator{
 
 private final LoggerContext loggerContext;
 
 public XMLConfigurator(URL url, LoggerContext loggerContext) {
  this.url = url;//文件url
  this.loggerContext = loggerContext;
 }
 
 @Override
 public void doConfigure() {
  try{
   DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
   DocumentBuilder documentBuilder = factory.newDocumentBuilder();
   Document document = documentBuilder.parse(url.openStream());
   parse(document.getDocumentElement());
   ...
  }catch (Exception e){
   ...
  }
 }
 private void parse(Element document) throws IllegalAccessException, ClassNotFoundException, InstantiationException {
  //do parse...
 }
}

解析时，装配LoggerContext，将配置中的Logger/Root Logger/Appender等信息构建完成，填充至传入的LoggerContext

现在还需要一个初始化的入口，用于加载/解析配置文件，提供加载/解析后的全局LoggerContext

public class ContextInitializer {
 final public static String AUTOCONFIG_FILE = "logc.xml";//默认使用xml配置文件
 final public static String YAML_FILE = "logc.yml";

 private static final LoggerContext DEFAULT_LOGGER_CONTEXT = new LoggerContext();
 
 /**
 * 初始化上下文
 */
 public static void autoconfig() {
  URL url = getConfigURL();
  if(url == null){
   System.err.println("config[logc.xml or logc.yml] file not found!");
   return ;
  }
  String urlString = url.toString();
  Configurator configurator = null;

  if(urlString.endsWith("xml")){
   configurator = new XMLConfigurator(url,DEFAULT_LOGGER_CONTEXT);
  }
  if(urlString.endsWith("yml")){
   configurator = new YAMLConfigurator(url,DEFAULT_LOGGER_CONTEXT);
  }
  configurator.doConfigure();
 }

 private static URL getConfigURL(){
  URL url = null;
  ClassLoader classLoader = ContextInitializer.class.getClassLoader();
  url = classLoader.getResource(AUTOCONFIG_FILE);
  if(url != null){
   return url;
  }
  url = classLoader.getResource(YAML_FILE);
  if(url != null){
   return url;
  }
  return null;
 }
 
 /**
 * 获取全局默认的LoggerContext
 */
 public static LoggerContext getDefautLoggerContext(){
  return DEFAULT_LOGGER_CONTEXT;
 }
}

现在还差一步，将加载配置文件的方法嵌入LoggerFactory，让LoggerFactory.getLogger的时候自动初始化，来改造一下StaticLoggerFactory：

public class StaticLoggerFactory implements ILoggerFactory {

 private LoggerContext loggerContext;

 public StaticLoggerFactory() {
  //构造StaticLoggerFactory时，直接调用配置解析的方法，并获取loggerContext
  ContextInitializer.autoconfig();
  loggerContext = ContextInitializer.getDefautLoggerContext();
 }
}

现在，一个日志框架就已经基本完成了。虽然还有很多细节没有完善，但主体功能都已经包含，麻雀虽小五脏俱全

完整代码

本文中为了便于阅读，有些代码并没有贴上来，详细完整的代码可以参考：

https://github.com/kongwu-/logc

相关问题

  • Java集合框架如何学习（Java集合框架学习笔记）

    Java集合框架学习笔记

    发布时间：2021-06-08

  • 新手如何自学Java框架（学习Java框架方法）

    Java是世界第一编程语言，这已经达成共识，是毋庸置疑的真理。框架是程序员们必学的知识点，而且是十分重要的应用，Spring、Struts、Hibernate也是经典中的经典，最常用的框架类型。

    发布时间：2021-06-08

  • java框架学起来快吗（java框架学起来容易吗）

    Java框架可以简化开发难度，更便于我们开发程序。所以学好Java框架还是比较重要的。Java的框架主要有：SpringMVC、Spring、Mybatis、Dubbo、Maven、RabbitMQ、Log4j、Ehcache、Redis、Shiro。不过这十个我们不需要都学会，只要学会其中四五个比较常用的就可以。框架很难，学起来不易的，在有人带的基础上，两周时间可以基本掌握，自己能写框架（模拟容框架的实现），理解它的思想。自学的话，我觉得你花20天到一个月时间会比较靠谱一些。根据你的基础，java基础

    发布时间：2020-12-07

  • JavaScript类框架知识点（介绍一个简单的JavaScript类框架）

    这篇文章主要介绍了一个简单的JavaScript类框架,有助于初学者理解JS类的创建与继承,需要的朋友可以参考下

    发布时间：2020-03-25

  • java和php框架吗（php开发和java开发有什么不同）

    Java和PHP都是编程语言，大家知道它们最大的区别就是一个是静态语言一个是动态语言吧。没错，Java是一种静态语言，PHP是一种动态语言PHP是一种解释执行的脚本语言，语法和C语言类似，易学易用，不懂电脑的非专业人员稍经学习也能使用PHP.而Java要先编译成Class文件，然后在Java虚拟机上执行，Java开发需要熟悉Java语法以及一些核心的架构，从而实现一种可复用的、跨平台的软件，Java培训比PHP培训要难学的多。java是纯面向对象开发，功能强大，分支众多

    发布时间：2020-11-17

  • java的三大框架难吗（学习java的三大框架容易吗吗）

    框架很难，学起来不容易的，在有人带的基础上，两周时间可以基本掌握，自己能写框架（模拟框架的实现），理解它的思想。自学的话，我觉得你花20天到一个月时间会比较靠谱一些。根据你的基础，java基础还是有一些的，静下心学，会掌握的。Java是世界第一编程语言，这已经达成共识，是毋庸置疑的真理。框架是程序员们必学的知识点，而且是十分重要的应用，Spring、Struts、Hibernate也是经典中的经典，最常用的框架类型。 1、先学习struts，struts是世

    发布时间：2020-12-04

  • java开发会用框架吗（java开发能用框架吗）

    框架只是为了方便，快速的构建自己的应用。 根本目的还是说为了分离我们的业务逻辑，方便维护。 我们一般的web项目都是分为视图层，控制层，业务层，持久层等 各个框架其实也是根据这些划分就行的，比如struts是衔接视图层和控制层的，hibernate是持久层的，spring是struts和hibernate的粘合剂，必不可少。当然还有其他的框架，也是一样的。 但是总归来讲还是为了分离业务，方便维护，快速开发。 1、采用框架一个重要的优点就是能够提升开发效率，如

    发布时间：2020-12-04

  • Java NIO框架Netty使用案例（Java NIO框架Netty简单使用的示例）

    本篇文章主要介绍了Java NIO框架Netty简单使用的示例,小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧

    发布时间：2020-03-19

  • 如何处理jQuery符号$与其他javascript 库、框架冲突的问题（完美解决jQuery符号$与其他javascript 库、框架冲突的问题）

    下面小编就为大家带来一篇完美解决jQuery符号$与其他javascript 库、框架冲突的问题。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧

    发布时间：2020-01-13

用户回答

9小时29分钟前回答

程序员学习路线之Java框架如何搭建

程序员学习路线之Java框架如何搭建？其实学习任何知识，体系和思路很重要。学习Java也是如此，尤其是掌握了好的学习方法，可以让我们事半功倍。相对其他编程语言，Java语言的特点是简单、易操作，但是想要学到其精髓，最重要的一步是学会如何搭建Java框架。根据每个人的学习方式、方法不同，可以制定具体的计划。今天为大家整理了搭建Java知识框架的几个方法，与大家分……

22小时1分钟前回答

Java各大框架视频下载之项目框架

Java始终排在第一位，这使它成为有史以来最享负盛誉的软件编程语言之一。及时的更新和新版本的发布使它成为一种充满活力的、有竞争力的编程语言。 但是，仅仅为你的下一个web应用程序开发项目选择这门顶级语言是不够的。在选择Java web框架时，你仍需要做出正确的选择。那么，你是否想知道如何为项目选择一个恰当的Java框架呢? 1： Spring Spring排在第一位，是由于它能够开……

最新更新

热门推荐