Java框架学习顺序是什么
- 更新时间:2021-10-07 10:35:24
- 编辑:吴伟懋
- 参考资料
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初学者都能顺利入门,真正掌握一门技能。
输出内容 - 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
用户回答

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

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