Java的目录是用户手动创建的，但是由于Java和OC不一样，有多个IDE所以大家都会遵循一定的目录规范，然后用IDE的设置制定目录的用处
Java的目录主要是分为「Sources」「Tests」「Resources」「Test Resources」「Exclude」几个目录，先上一张IntelliJ的「Project Structure」设置的图
可以看到不同的目录会用不同的颜色和图标标记出来
目录可以通过IDE指定，但是他们的功能是确定的
Java中的日期是Date包
import java.util.Date;
其中无参数构造函数返回当前时间
Date time = new Date();
日期的类是Date类，如果想要变为肉眼读懂的字符串需要用text包下的格式化类
import java.text.SimpleDateFormat;
可以按照字符串规律进行格式化
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyyMMdd");
String today = simpleDateFormat.format(new Date());
其中年月日的用「year」 「month」 「day」 「hour」 「minute」 「second」 的首字母表示，大写M代表Month，小写m代表Minute。
public static final String DATE_SHOW_FORMAT = "yyyy-MM-dd";
public static final String DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
public static final String DATE_SHORT_FORMAT = "yyyyMMdd";
public static final String DATE_MONTH_FORMAT = "yyyyMM";
public static final String DATE_TIMEC_FORMAT = "yyyyMMddHH24ssmm";
public static final String DATE_TIMES_FORMAT = "yyyyMMddhhmmss";
public static final String DATE_TIME_FORMAT_NO_SPLIT = "yyyyMMddHHmmss";
测试结论：
测试代码Throw
public void someMethod() throws Exception {
System.out.print("Execute Before\n");
try {
System.out.print("Execute Try\n");
int i = 1/0;
} catch (Exception e) {
System.out.print("Execute Catch\n");
throw e;
} finally {
System.out.print("Execute Finally\n");
}
System.out.print("Execute After\n");
}
测试输出Throw
Execute Before
Execute Try
Execute Catch
Execute Finally
测试代码Not Throw
public void someMethod() throws Exception {
System.out.print("Execute Before\n");
try {
System.out.print("Execute Try\n");
int i = 1/0;
} catch (Exception e) {
System.out.print("Execute Catch\n");
} finally {
System.out.print("Execute Finally\n");
}
System.out.print("Execute After\n");
}
测试输出Not Throw
Execute Before
Execute Try
Execute Catch
Execute Finally
Execute After
先去String中看看Split的函数的定义
*
* @param regex
* the delimiting regular expression
*/
public String[] split(String regex) {
return split(regex, 0);
}
可以看到其入参并不是你要作为标记的String字符串，而是一个正则表达式，而且其调用了另外一个函数，进入调用函数的细节
char ch = 0;
if (
//if判断第一种情况:判断输入
(
//第一种情况的判断1
(
//判断是不是仅输入了一个字符
regex.value.length == 1 &&
//输入字符不为以下其中一个
".$|()[{^?*+\\".indexOf(ch = regex.charAt(0)) == -1
)
//第一种情况的判断2
||
(
//输入字符为两个
regex.length() == 2 &&
//第一个Char为两个转义
regex.charAt(0) == '\\' &&
//第二个char字符不为0-9
(((ch = regex.charAt(1))-'0')|('9'-ch)) < 0 &&
//第二个char字符不为a-z
((ch-'a')|('z'-ch)) < 0 &&
//第二个char字符为A-Z
((ch-'A')|('Z'-ch)) < 0
)
)
&&
//第二种情况:为合法的char字符
(ch < Character.MIN_HIGH_SURROGATE || ch > Character.MAX_LOW_SURROGATE)
)
｛
//以ch字符为关键字进行偏移分割法
....
｝else {
//以输入字符为正则表达式进行分割法
....
}
通过总结发现
if判断为true的条件
满足以上两个条件就进行正常字符分割，否则进行正则表达式匹配
所以说以点分割要避开正则表达式的判断，需要用两个转义字符，从转义字符上理解
例子
String str = "com.alanli.io"
String[] strArray = str.split("\\.");
//String[] strArray = str.split("."); //错误的方法进入了正则分割
Java和MySQL需要注意的是数据类型的「长度」 ，有些时候需要储存的数字过大，INT类型有可能存不下。
| 类型名称 | 显示长度 | 数据库类型 | JAVA类型 | JDBC类型索引(int) |
|---|---|---|---|---|
| VARCHAR | L+N | VARCHAR | java.lang.String | 12 |
| CHAR | N | CHAR | java.lang.String | 1 |
| BLOB | L+N | BLOB | java.lang.byte[] | -4 |
| TEXT | 65535 | VARCHAR | java.lang.String | -1 |
| INTEGER | 4 | INTEGER UNSIGNED | java.lang.Long | 4 |
| TINYINT | 3 | TINYINT UNSIGNED | java.lang.Integer | -6 |
| SMALLINT | 5 | SMALLINT UNSIGNED | java.lang.Integer | 5 |
| MEDIUMINT | 8 | MEDIUMINT UNSIGNED | java.lang.Integer | 4 |
| BIT | 1 | BIT | java.lang.Boolean | -7 |
| BIGINT | 20 | BIGINT UNSIGNED | java.math.BigInteger | -5 |
| FLOAT | 4+8 | FLOAT | java.lang.Float | 7 |
| DOUBLE | 22 | DOUBLE | java.lang.Double | 8 |
| DECIMAL | 11 | DECIMAL | java.math.BigDecimal | 3 |
| BOOLEAN | 1 | 同TINYINT | ||
| ID | 11 | PK (INTEGER UNSIGNED) | java.lang.Long | 4 |
| DATE | 10 | DATE | java.sql.Date | 91 |
| TIME | 8 | TIME | java.sql.Time | 92 |
| DATETIME | 19 | DATETIME | java.sql.Timestamp | 93 |
| TIMESTAMP | 19 | TIMESTAMP | java.sql.Timestamp | 93 |
| YEAR | 4 | YEAR | java.sql.Date | 91 |
从 -2^63 (-9223372036854775808) 到 2^63-1 (9223372036854775807) 的整型数据（所有数字）。存储大小为 8 个字节。
BIGINT已经有长度了，在mysql建表中的length，只是用于显示的位数
从 -2^31 (-2,147,483,648) 到 2^31 – 1 (2,147,483,647) 的整型数据（所有数字）。存储大小为 4 个字节。int 的 SQL-92 同义字为 integer。
从 -2^15 (-32,768) 到 2^15 – 1 (32,767) 的整型数据。存储大小为 2 个字节。
从 0 到 255 的整型数据。存储大小为 1 字节。
INT的范围还是比较小的，程序中如果超过10位的数据（比如转化后的IP地址），就会超过INT类型支持的范围，所以就需要就采用BIGINT。
int(M) 在 integer 数据类型中，M 表示最大显示宽度。在 int(M) 中，M 的值跟 int(M) 所占多少存储空间并无任何关系。和数字位数也无关系 int(3)、int(4)、int(8) 在磁盘上都是占用 4 btyes 的存储空间。
IPv4可以以两种形式储存到数据库，第一种就是肉眼可以见的String类型，第二种就是转化为Int类型储存
//String Type
String ipStr = "127.0.0.1"
//Integer/Long Type
String ipNum = 2130706433;
之所以使用数字进行储存，我觉得是因为数字读写比较快，但是IPv6貌似不能转化为数字。目前还没遇到这个问题。
Java的官方库并没有提供转化工具，所以需要借助第三方库或者自己写
转化String类型到Long类型，转化出来的地址是无符号的Long型，因为255.255.255.255的地址转化完是『4294967295』，大于了Integer类型的最大范围，所以数据库中要使用『BIGINT』进行储存。
public static String integerToStringIPv4(int ip) {
return ((ip >> 24 ) & 0xFF) + "." +
((ip >> 16 ) & 0xFF) + "." +
((ip >> 8 ) & 0xFF) + "." +
( ip & 0xFF);
}
public static Long StringIPv4ToLong(String addr) {
String[] addrArray = addr.split("\\.");
long num = 0;
for (int i=0;i<addrArray.length;i++) {
int power = 3-i;
num += ((Integer.parseInt(addrArray[i])%256 * Math.pow(256,power)));
}
return num;
}
转化String类型到int类型，转化出来的地址是有符号的int基本类型，255.255.255.255的地址转化完是『－1』数据库中可以使用『INT』进行储存。
import com.google.common.net.InetAddresses;
import java.net.InetAddress;
import java.net.UnknownHostException;
public static String integerToStringIPv4Google(int ip) {
return InetAddresses.fromInteger(ip).toString();
}
public static Integer StringIPv4ToIntegerGoogle(String addr) {
try {
InetAddress javaInet = InetAddress.getByName(addr)
return InetAddresses.coerceToInteger(javaInet);
} catch (UnknownHostException e) {
return 0;
}
}
WebFramework简称Web框架,比较知名的比如Spring,其主要是通过技术手段管理模块中的类的生命周期,更加有效的管理内存.
如果想要加深框架的理解,建议手动编写黄勇先生书的1-3章节,由于黄勇先生并未对具体功能做细致解释,所以这篇文章仅仅是补充作用,而且编写时一定要用JDK1.6和Tomcat7,我用JDK1.8和Jetty9代码没有跑起来…..
由于Web开发经验有限,所以整篇文章理解可能会存在谬误的地方,如果碰到,你跳进屏幕来打我呀 ㄟ<(=▔.▔=)>ㄏ
除了Spring这种常用的框架外,阿里巴巴黄勇的书提出了一个观点,应该首先了解框架怎么运作,再去学习框架,从而获得更加清醒的认识.本人由于是初学Java,所以先根据其书1-3章,重现了其轻量级框架SmartFramework,并且进行了一定的总结.
首先进行一些准备工作
整个框架除了主流程之外还使用到了以下工具类
常用工具中包括:字符串转换/容器是否为空判断/Json编码解码/URL编码解码/数据流编码解码/配置文件读取
注解的详细介绍见另一篇文章,SmartFramework四个注解
四个注解的ElementType分别是Action(Method),Controller(TYPE),Service(TYPE),Inject(Field).
Bean类共有五个,其中框架类的两个
前端类3个
以下是工作流程图
以下是HttpServlet代码示例
@Override
public void init(ServletConfig servletConfig) throws ServletException {
HelperLoader.init();
.....
}
通过HelperLoader进行循环加载
public static void init() {
Class<?>[] classList = {
ClassHelper.class,
BeanHelper.class,
InjectHelper.class,
ControllerHelper.class
};
for (Class<?> cls: classList) {
ClassUtil.loadClass(cls.getName(),false);
}
}
所有的Helper变量都拥有两个部分
ClassHelper静态变量和静态区代码
private static final Set<Class<?>> CLASS_SET;
static {
String basePackage = ConfigHelper.getAppBasePackage();
CLASS_SET = ClassUtil.getClassSet(basePackage);
}
BeanHelper静态变量和静态代码
private static final Map<Class<?>, Object> BEAN_MAP = new HashMap<Class<?>, Object>();
static {
Set<Class<?>> beanClassSet = ClassHelper.getBeanClassSet();
for (Class<?> beanClass : beanClassSet) {
Object obj = ReflectionUtil.newInstance(beanClass);
BEAN_MAP.put(beanClass,obj);
}
}
黄勇先生在书中将依赖注入放入了Iochelper.java,个人认为是黄勇先生在一开始就混淆了依赖注入和控制反转的概念,所以我将该文件称为InjectHelper
InjectHelper的静态区代码
public final class InjectHelper {
static {
//Get All Bean Class And Bean Instance
Map<Class<?>, Object> beanMap = BeanHelper.getBeanMap();
if(CollectionUtil.isNotEmpty(beanMap)) {
//一级遍历Bean Map
for (Map.Entry<Class<?>,Object>beanEntry : beanMap.entrySet()) {
//获取Bean类和实例
Class<?> beanClass = beanEntry.getKey();
Object beanInstance = beanEntry.getValue();
//获取一级遍历中每个Bean类所定义的成员变量Bean Field
Field[] beanFields = beanClass.getDeclaredFields();
if (ArrayUtil.isNotEmpty(beanFields)) {
//对Bean Fields进行二级遍历
for (Field beanField : beanFields) {
//检查存在Inject注解的Field(备注1)
if (beanField.isAnnotationPresent(Inject.class)) {
Class<?> beanFieldClass = beanField.getType();
Object beanFieldInstance = beanMap.get(beanFieldClass);
//BeanMap中存在已经被IOC实例化的对象
if (beanFieldInstance !=null) {
//进行依赖注入,重新链接被IOC切断的耦合
ReflectionUtil.setField(beanInstance,beanField,beanFieldInstance);
}
}
}
}
}
}
}
}
依赖注入中最关键的是备注1,其配合IOC中第三第四步来共同使用
由于控制反转(IOC)经常和依赖注入(DI)经常配合使用,所以好多将两者混为一谈,其实并不是这样.IOC是一种去耦合手段,而DI则是从新链接耦合的手段
按照思维逻辑每一个请求(Request)都是调用一个服务端功能,而去接收并处理这个请求的就是一个接收的方法(Handler),这一步就是将前端被标有Action注解的方法(Method)对应到每个请求的URL地址上.
ControllerHelper的静态代码
public class ControllerHelper {
private static final Map<Request,Handler> ACTION_MAP = new HashMap<Request, Handler>();
static {
//获取所有的ControllerClass
Set<Class<?>> controllerClassSet = ClassHelper.getControllerClassSet();
if (CollectionUtil.isNotEmpty(controllerClassSet)) {
//一级遍历ControllerClass
for(Class<?> controllerClass : controllerClassSet) {
//取出一级遍历中的所有Method
Method[] methods = controllerClass.getMethods();
if (ArrayUtil.isNotEmpty(methods)) {
//二级遍历Method
for (Method method : methods) {
//查询带有Action注解的Method
if (method.isAnnotationPresent(Action.class)) {
Action action = method.getAnnotation(Action.class);
String mapping = action.value();
//分析Method中value的组成
if(mapping.matches("\\w+:/\\w*")) {
String[] array = mapping.split(":");
if (ArrayUtil.isNotEmpty(array) && array.length == 2) {
String requestMethod = array[0];
String requestPath = array[1];
//实例化Request和Handler
Request request = new Request(requestMethod,requestPath);
Handler handler = new Handler(controllerClass,method);
//放入映射关系ActionMap
ACTION_MAP.put(request, handler);
}
}
}
}
}
}
}
}
}
在SmartFramework框架搭建好之后,可以通过Jar包或者Maven的形式加入新的Project.在新的Project中使用需要遵循以下方案
新ProjectController举例,Controller是Servlet的一个延伸,主要是处理HTTP请求中的逻辑关系
@Controller
public class TestController {
//此处对Service的Class进行注入,ServiceClass由IOC实例化
@Inject
private TestService testService;
//返回一个DataBean
@Action("get:/outputString")
public Data doTest(Param param) {
String string = testService.outputString();
return new Data(string);
}
//返回一个ViewBean
@Action("get:/index")
public View doIndex(Param param) {
return new View("index.jsp");
}
}
新ProjectService举例,Service是实际后台的逻辑,处理数据库操作等事务并作为一个Model被Controller引用
@Service
public class TestService {
public String outputString() {
String string = "Test Service Done";
return string;
}
}
根据文章Servlet的总结每一个HTTP请求都需要一个Servlet进行接收,这样的话会导致需要编写大量的Servlet让代码冗余不堪,而且每一个Servlet都需要一个实例占用内存导致资源浪费,而框架就可以解决这些问题.
由于框架的这些处理,使得接口的开发更加清晰,而且类似于内存和生命周期的管理等复杂问题则不需要程序员考虑.
框架还有一个重要的特性是AOP,面向切面的编程,由于是初步学习,准备等实际业务能力上来之后再来体会其中的奥妙
以往在写前端的时候,自己思考过一种单例模式,万万没想到啊,后台框架这种反转控制和依赖注入把内存玩的这么溜,真是大开眼界.
在Web框架中,反转控制(IOC)的实例化,依赖注入的赋值以及接口Handle函数的触发都是利用了反射机制,如同OC的字符串反射一样,Java里的反射也是通过类或Class进行内存的运行时(Runtime)操作.
在Smart框架中,反射用到三个概念
package org.smart4j.framework.util;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class ReflectionUtil {
private static final Logger LOGGER = LoggerFactory.getLogger(ReflectionUtil.class);
public static Object newInstance(Class<?> cls) {
Object instance = null;
try {
instance = cls.newInstance();
} catch (InstantiationException e) {
LOGGER.error("new instance failure",e);
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return instance;
}
public static Object invokeMethod(Object obj, Method method, Object args) {
Object result = null;
try {
method.setAccessible(true);
result = method.invoke(obj,args);
} catch (IllegalAccessException e) {
LOGGER.error("invoke method failure",e);
throw new RuntimeException(e);
} catch (InvocationTargetException e) {
e.printStackTrace();
}
return result;
}
public static void setField(Object obj, Field field, Object value) {
try {
field.setAccessible(true);
field.set(obj, value);
} catch (IllegalAccessException e) {
LOGGER.error("set field failure",e);
throw new RuntimeException(e);
}
}
}
注解是Java5中提出对代码进行管理的一种方式,其相当于备注的作用.在Web框架中使用注解对使用框架的类/方法/变量进行管理.
如果你想自己定义一个注解,需要使用到元注解(Meta-Annotation),元注解共有4个,有Java源生提供.
在四个元注解中,Target和Retention是最常使用的,而后两个是可选的.
@Target说明了Annotation所修饰的对象范围,就是该注解可以用在什么地方,有的只能作用于类,而有的只能作用于方法等等.取值(ElementType)有：
@Retention定义了该Annotation被保留的时间长短,表示需要在什么级别保存该注解信息，用于描述注解的生命周期
1.SOURCE: 在Java源文件中有效（即到了Class文件就没了）
2.CLASS: 在Class文件中有效（即加载到内存就没了）
3.RUNTIME: 在运行时有效（到了内存要执行了还有）
这个就比较容易理解,一般框架中都是RUNTIME,因为都是动态去分析这些注解.
由于注解的载体(表现形式)是一种接口Interface,所以说要遵循接口的一些规则,其内部变量都是以函数形式存在,比如以下这个自定义注解
Custom是用于注解Class的一个注解,其声明周期可以存活到内存中的运行时
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Custom {
//String value default "value"; //错误的定义使用成员值
String value() default "value"; //正确的定义使用函数
String name() default "className";
}
如果想要定义一个值来保存字符串,必须使用value()函数形式,而不是value这种成员值.
在使用注解时,可以对注解的成员进行赋值,如果不赋值则取default值
@Custom(value = "new value", name = "new name")
根据Java文档如果不适用指定成员的赋值,则是对value成员赋值
//If there is just one element named value, then the name can be omitted
@Custom("new value")
Java的代码都是运行在JVM虚拟机中的,使用类加载机制来完成代码的运行,具体内容还不是很了解,但是类加载机制总需要有一个线程来操作,Web框架中的类加载工具就是获取到这个线程,并把框架里的类加载进去.
package org.smart4j.framework.util;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.smart4j.framework.util.tool.StringUtil;
import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.net.JarURLConnection;
import java.net.URL;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.Set;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
public final class ClassUtil {
private static final Logger LOGGER = LoggerFactory.getLogger(ClassUtil.class);
public static Set<Class<?>> getClassSet (String packageName) {
//init a Classset
Set<Class<?>> classSet = new HashSet<Class<?>>();
//loop for find Class
try {
Enumeration<URL> urls = getClassLoader().getResources(packageName.replace(".","/"));
while (urls.hasMoreElements()) {
URL url = urls.nextElement();
if (url != null) {
String protocol = url.getProtocol();
if (protocol.equals("file")) {
String packagePath = url.getPath().replaceAll("%20"," ");
addClass(classSet, packagePath,packageName);
}else if (protocol.equals("jar")) {
JarURLConnection jarURLConnection = (JarURLConnection)url.openConnection();
if (jarURLConnection != null) {
JarFile jarFile = jarURLConnection.getJarFile();
if (jarFile != null) {
Enumeration<JarEntry> jarEnties = jarFile.entries();
while (jarEnties.hasMoreElements()) {
JarEntry jarEntry = jarEnties.nextElement();
String jarEntryName = jarEntry.getName();
if (jarEntryName.endsWith(".class")) {
String className = jarEntryName.substring(0, jarEntryName.lastIndexOf(".")).replaceAll("/",".");
doAddClass(classSet,className);
}
}
}
}
}
}
}
} catch (IOException e) {
LOGGER.error("get class set failure", e);
throw new RuntimeException(e);
}
//return ClassSet
return classSet;
}
private static void doAddClass(Set<Class<?>> classSet, String className) {
Class<?> cls = loadClass(className, false);
classSet.add(cls);
}
private static void addClass(Set<Class<?>> classSet, String packagePath, final String packageName) {
final File[] files = new File(packagePath).listFiles(new FileFilter() {
public boolean accept(File pathname) {
return (pathname.isFile() && pathname.getName().endsWith(".class"))|| pathname.isDirectory();
}
});
for (File file: files) {
//Get File name
String fileName = file.getName();
//
if (file.isFile()) {
String className = fileName.substring(0,fileName.lastIndexOf("."));
if (StringUtil.isNotEmpty(packageName)) {
className = packageName+"."+className;
}
doAddClass(classSet, className);
}else {
String subPackagePath = fileName;
if (StringUtil.isNotEmpty(packagePath)) {
subPackagePath = packagePath + "/" + subPackagePath;
}
String subPackageName = fileName;
if (StringUtil.isNotEmpty(packageName)) {
subPackageName = packageName + "." +subPackageName;
}
addClass(classSet, subPackagePath, subPackageName);
}
}
}
public static Class<?> loadClass(String className, boolean isInitialized) {
Class<?> cls;
try {
cls = Class.forName(className,isInitialized, getClassLoader());
} catch (ClassNotFoundException e) {
LOGGER.error("load class failure",e);
throw new RuntimeException(e);
}
return cls;
}
public static ClassLoader getClassLoader() {
return Thread.currentThread().getContextClassLoader();
}
}
缺失模块。
1、请确保node版本大于6.2
2、在博客根目录（注意不是yilia根目录）执行以下命令：
npm i hexo-generator-json-content --save
3、在根目录_config.yml里添加配置：
jsonContent:
meta: false
pages: false
posts:
title: true
date: true
path: true
text: false
raw: false
content: false
slug: false
updated: false
comments: false
link: false
permalink: false
excerpt: false
categories: false
tags: true