JavaBean基于Builder,通用JSON解析,代码生成器

# 一个类包含：类名，属性列表和内部类指针 
class Clazz 
def initialize(cls_name) 
@cls_name = cls_name 
@attrs=[] 
@lead_cls_names=nil  #前面有几个前导类名 

@list_attrs = []
end 
def cls_name 
@cls_name 
end 


attr_accessor :attrs, :lead_cls_names ,:list_attrs
end 


#属性 
class Attr 
def initialize(type=nil,name=nil) 
@type ,@name=type,name 
end 
attr_accessor :type, :name 
end 


class Env 
def initialize() 
@clz_list = []        #类的容器 
@cur_clz = nil        #当前类 
@attr = nil      #当前属性 
@attr_index=0         #当前类的第几个属性 
@clz_index=0      #当前属于第几个类 
@cls_print_queue=nil  #类打印队列 

@cur_cls_list_attrs_index = 0
end 

attr_accessor :clz_list,:cur_clz,:attr,:attr_index,:clz_index,:cur_cls_list_attrs_index 
end 


$env = Env.new 


def print_clz_list              #测试容器数据 
$env.clz_list.each do |clzz| 
lead_cls_names = clzz.lead_cls_names 
print "============" 
lead_cls_names.each do |lead_names| 
print lead_names + "-" 
end 
print "#{clzz.cls_name}============\n" 

attrs = clzz.attrs 
attrs.each do |attr| 
puts attr.type + "=" + attr.name 
end 
end 
end 


def print_cls_head(i) 
clazz = $env.clz_list[i] 
lead_clz_names = clazz.lead_cls_names 
lead_num = lead_clz_names.size 
cls_name = clazz.cls_name 
template = "" 
if(i == 0) 
template += "public class #{cls_name}{\n" 
else 
template += "\n" 
template += "\t" * lead_num 
template += "public static class #{cls_name}{\n" 
end 

template += "\n"

template += "\t" * lead_num + "\t"

template += "private #{cls_name}(){}\n"

template 

end 


#返回前导类的个数 
def get_lead_num(i) 
lead_cls_names = $env.clz_list[i].lead_cls_names 
lead_num = 0 
if(lead_cls_names == nil) 
lead_num = 0 
else 
lead_num = lead_cls_names.size 
end 

lead_num 
end 


def print_cls_end(i) 
lead_num = get_lead_num(i) 
template = "\t" * lead_num + "}\n\n" 
template 
end 


def print_attrs(i) 
lead_type = "\t" * get_lead_num(i) + "\t" 
attrs = $env.clz_list[i].attrs 

template = "\n" 
attrs.each do |attr| 
type = attr.type 
name = attr.name 
template += "#{lead_type}private #{type} #{name};\n"  
end 

template 

end 


def get_template(i) 
clazz = $env.clz_list[i] 
lead_type = "\t" * get_lead_num(i) + "\t" 
template = "\n" 
clazz.attrs.each do |attr| 
first_cap_name = attr.name[0].upcase + attr.name[1..attr.name.size-1] 
template += "#{lead_type}public #{attr.type} get#{first_cap_name}(){\n" 
template += "#{lead_type}\treturn #{attr.name};\n" 
template += "#{lead_type}}\n\n" 
end 
template 
end 


def builder_template(i=0) 
clazz = $env.clz_list[i] 
cls_name = clazz.cls_name 
instance_name = cls_name[0].downcase + cls_name[1..cls_name.size-1] 
attrs = clazz.attrs 

lead_type = "\t" * get_lead_num(i) + "\t" 

template = "#{lead_type}public static class Builder{\n" 

template += "#{lead_type}\tprivate #{cls_name} #{instance_name} = new #{cls_name}();\n\n" 
attrs.each do |attr| 
first_cap_name = attr.name[0].upcase + attr.name[1..attr.name.size-1] #首字母大写 
template += "#{lead_type}\tpublic Builder set#{first_cap_name}(#{attr.type} #{attr.name}){\n" 
template += "#{lead_type}\t\t#{instance_name}.#{attr.name} = #{attr.name};\n" 
template += "#{lead_type}\t\treturn this;\n" 
template += "#{lead_type}\t}\n\n" 
end 

template += "#{lead_type}\tpublic #{cls_name} get#{cls_name}(){\n" 
template += "#{lead_type}\t\treturn #{instance_name};\n" 
template +="#{lead_type}\t}\n" 

template += "#{lead_type}}\n" 


template 

end 


#逆序排序 
def get_print_cls_done_queue 
cls_list = $env.clz_list 
loc_cls_list=cls_list.sort{|i,j| j.lead_cls_names.size<=>i.lead_cls_names.size} 
loc_cls_list 
end 


def print_cur_cls_end(cls) 
lead_types="\t"*cls.lead_cls_names.size 
#puts "#{cls.lead_cls_names.size}个tabs" 
lead_types+"}\n" 
end 




def genBean 
clazz_list=$env.clz_list 
cls_done_queue=get_print_cls_done_queue 
print_queue_size=cls_done_queue.size 
print_queue_index=0 
0.upto(clazz_list.size-1) do |i| 
puts print_cls_head(i) 
puts print_attrs(i) 
puts get_template(i) 
puts builder_template(i) 

#查看是否可以为当前类打印结束标签 
cur_lead_types_num = clazz_list[i].lead_cls_names.size 
print_queue_lead_types_num=cls_done_queue[print_queue_index].lead_cls_names.size 
if(cur_lead_types_num == print_queue_lead_types_num) 
puts print_cur_cls_end(cls_done_queue[print_queue_index]) 
print_queue_index += 1 
end 
end 

#将剩余的未结束类结束其花括号标签 
print_queue_index.upto(print_queue_size-1) do |i| 
puts print_cur_cls_end(cls_done_queue[i]) 
end 

=begin 
(clazz_list.size-1).downto(0) do |i| 
puts print_cls_end(i) 
end 
=end 
end 




=begin 
$clz_list = []     #类的容器 
$cur_clz = nil     #当前类 
$attr = nil  #当前属性 
$attr_index=0      #当前类的第几个属性 
$clz_index=0  #当前属于第几个类 
=end 


def json_builder(cls=$env.clz_list[0])
	cls_name = cls.cls_name
	if(cls_name == $env.clz_list[0].cls_name)
		the_outerest_cls = $env.clz_list[0]
		cls_name = the_outerest_cls.cls_name
		template = "public static #{cls_name} get#{cls_name}(JSONObject jsonObj){\n"
		template += "\tif(jsonObj == null) return null;\n"

		template += builder_attrs
		template += "}\n"

		template << json_get_list

		template

	else
		template = "private static #{cls_name} get#{cls_name}(JSONObject jsonObj){\n"
		template += "\tif(jsonObj == null) return null;\n"

		template += builder_attrs(cls)
		template += "}\n"

		template << json_get_list(cls)

		template

	end
	end

def builder_attrs(cls = $env.clz_list[0])
	template = ""
	cls_name = cls.cls_name
	attrs = cls.attrs
	template += "\treturn new #{cls_name}.Builder()\n"
	
	attrs.each do |attr|
		type = attr.type
		name = attr.name
		cap_name = name.capitalize
		cap_type = type.capitalize


	if /^List/ =~ type
		list_attrs = cls.list_attrs
		list_attrs[$env.cur_cls_list_attrs_index] = attr

		template += "\t\t.set#{cap_name}(get#{cap_name}(jsonObj))\n"
		next
	end

		template += "\t\t.set#{cap_name}"
		template += "(jsonObj.opt#{cap_type}(\"#{name}\"))\n"
	end
	template = template.slice(0,template.size-1);
	template << ".get#{cls_name}();\n"

end

def json_get_list(cls=$env.clz_list[0])
	template = "\n\n"
	cls_name = cls.cls_name

	list_attrs = cls.list_attrs

	attr = list_attrs[0]

	list_attrs.each do |attr|
		template << json_get_list_attr(attr)
	end

	template
	
end

def json_get_list_attr(attr)
	template = ""
	attr_type = attr.type
	attr_name = attr.name

	cap_attr_name = attr.name.capitalize

	key_word = nil
	first_word_downcase_kw=nil

	if /^List<(.*?)>/ =~ attr_type
		key_word = $1
		first_word_downcase_kw = key_word[0].downcase + key_word[1..key_word.size-1]
	end
	
	template << "private static #{attr_type} get#{cap_attr_name}(JSONObject jsonObj){\n"

	template += "\tJSONArray jsonArray = jsonObj.optJSONArray(\"#{first_word_downcase_kw}\");\n"

	template += "\tif(jsonArray == null) return null;\n"

	template += "\tfinal int len = jsonArray.length();\n"
	template += "\t#{attr_type} result = new ArrayList<#{key_word}>();\n"
	template += "\tfor(int i = 0; i < len; i++){\n"
	template += "\t\tJSONObject innerJSONObj = jsonArray.optJSONObject(i);\n"
	template += "\t\tresult.add(get#{key_word}(innerJSONObj));\n"

	template += "\t}\n"

	template += "\treturn result;\n"
	
	template += "}\n"


	cls = find_cls_from_kw(key_word)
	
	template <<	json_builder(cls)

	template

end

def find_cls_from_kw(key_word)
	cls_list = $env.clz_list
	cls_list.each do |cls|
		cls_name = cls.cls_name
		if(cls_name == key_word)
			return cls
		end
	end

	nil
end

File.open("Test.txt"){|f| 
f.each_line do |line| 
line = line.gsub("\n","") #去除换行符 


if /^Cls/ =~ line  #碰到以Cls开头，表名以下的属性属于该类 
type_cls_names = line.split(":") #将该行分成两部分，第一部分为Cls,第二部分为类名集合，每个类名之间用-相连 
cls_names = type_cls_names[1].split("-")  #获取类名集合 


cls_name = cls_names[cls_names.size-1]  
$env.cur_clz = Clazz.new(cls_name) 

$env.cur_clz.lead_cls_names = cls_names[0...cls_names.size-1]  #获取前导类名集合 

$env.clz_list[$env.clz_index] = $env.cur_clz;  
$env.clz_index += 1 

$env.attr_index = 0            #重置attr_index 

else               #将该类的属性，填充在该类中 
if $env.cur_clz == nil 
puts "nil" 
else 
attr_type_name = line.split(":") 
attr_type=attr_type_name[0] 
attr_name=attr_type_name[1] 
$env.attr = Attr.new(attr_type,attr_name) 
$env.cur_clz.attrs[$env.attr_index] = $env.attr 
$env.attr_index += 1 


end 
end 

end 

=begin 
print_clz_list 

puts get_template(0) 

puts builder_template 
=end 

# -------- generate bean base on builder pattern
#genBean 

#-----generate json parser template code
puts json_builder 
}

Java Code:

public static Person getPerson(JSONObject jsonObj){
	if(jsonObj == null) return null;
	return new Person.Builder()
		.setName(jsonObj.optString("name"))
		.setAge(jsonObj.optInt("age"))
		.setSex(jsonObj.optInt("sex"))
		.setDescription(jsonObj.optString("description"))
		.setDeses(getDeses(jsonObj));
}


private static List<Des> getDeses(JSONObject jsonObj){
	JSONArray jsonArray = jsonObj.optJSONArray("des");
	if(jsonArray == null) return null;
	final int len = jsonArray.length();
	List<Des> result = new ArrayList<Des>();
	for(int i = 0; i < len; i++){
		JSONObject innerJSONObj = jsonArray.optJSONObject(i);
		result.add(getDes(innerJSONObj));
	}
	return result;
}
private static Des getDes(JSONObject jsonObj){
	if(jsonObj == null) return null;
	return new Des.Builder()
		.setSalary(jsonObj.optInt("salary"))
		.setLibs(getLibs(jsonObj));
}


private static List<Lib> getLibs(JSONObject jsonObj){
	JSONArray jsonArray = jsonObj.optJSONArray("lib");
	if(jsonArray == null) return null;
	final int len = jsonArray.length();
	List<Lib> result = new ArrayList<Lib>();
	for(int i = 0; i < len; i++){
		JSONObject innerJSONObj = jsonArray.optJSONObject(i);
		result.add(getLib(innerJSONObj));
	}
	return result;
}
private static Lib getLib(JSONObject jsonObj){
	if(jsonObj == null) return null;
	return new Lib.Builder()
		.setType(jsonObj.optInt("type"))
		.setShit(jsonObj.optString("shit"));
}

测试配置文件如下：

Cls:Person
String:name
int:age
int:sex
String:description
List<Des>:deses
Cls:Person-Des
int:salary
List<Lib>:libs
Cls:Person-Des-Lib
int:type
String:shit