package foundation.server.config;
|
|
import java.io.File;
|
import java.io.FileInputStream;
|
import java.io.IOException;
|
import java.io.InputStream;
|
import java.util.ArrayList;
|
import java.util.Iterator;
|
import java.util.List;
|
import java.util.Set;
|
|
import org.apache.logging.log4j.LogManager;
|
import org.apache.logging.log4j.Logger;
|
import org.dom4j.Document;
|
import org.dom4j.Element;
|
import org.dom4j.io.SAXReader;
|
|
import foundation.route.RouteTable;
|
import foundation.server.ControllerConfig;
|
import foundation.server.Initializer;
|
import foundation.server.InitializerContainer;
|
import foundation.server.ObjectCreator;
|
import foundation.server.VirtualPathConfig;
|
import foundation.translator.Translator;
|
import foundation.util.CaseInsensitiveSet;
|
import foundation.util.Util;
|
|
|
public class ServerAssembleLoader {
|
|
protected static Logger logger;
|
private static ServerAssembleLoader instance;
|
private static InitializerContainer initializerContainer;
|
private static List<VirtualPathConfig> virtualPathList;
|
private static List<ControllerConfig> controllerList;
|
public static Set<String> activeDataSourceList;
|
|
static {
|
logger = LogManager.getLogger(ServerAssembleLoader.class);
|
initializerContainer = InitializerContainer.getInstance();
|
}
|
|
private ServerAssembleLoader() {
|
virtualPathList = new ArrayList<VirtualPathConfig>();
|
controllerList = new ArrayList<ControllerConfig>();
|
activeDataSourceList = new CaseInsensitiveSet();
|
}
|
|
public synchronized static ServerAssembleLoader getInstance() {
|
if (instance == null) {
|
instance = new ServerAssembleLoader();
|
}
|
|
return instance;
|
}
|
|
public static void staticLoad() throws Exception {
|
ServerAssembleLoader instance = getInstance();
|
instance.load();
|
}
|
|
public void load() throws Exception {
|
//1. load configuration file
|
String path = Configer.getPath_ServerConfig();
|
File file = new File(path);
|
loadOneFile(file);
|
|
//2. create virtual path
|
for (VirtualPathConfig virtualPath: virtualPathList) {
|
createOneRoute(virtualPath);
|
}
|
|
//3. create controller path
|
for (ControllerConfig callableConfig: controllerList) {
|
createOneRoute(callableConfig);
|
}
|
}
|
|
private static void loadOneFile(File file) throws Exception {
|
try {
|
logger.debug("load config file:" + file);
|
InputStream inputStream = new FileInputStream(file);
|
|
try {
|
SAXReader reader = new SAXReader();
|
reader.setValidation(false);
|
|
Document doc = reader.read(inputStream);
|
Element root = doc.getRootElement();
|
|
loadFreeVisit(root);
|
loadRouteConfig(root);
|
loadInitializers(root);
|
loadActiveDataSource(root);
|
}
|
finally {
|
try {
|
inputStream.close();
|
} catch (IOException e) {
|
}
|
}
|
} catch (Exception e) {
|
logger.error("can not load dispatch file: " + file);
|
logger.error(e);
|
throw e;
|
}
|
}
|
|
private static void loadFreeVisit(Element root) throws Exception {
|
Iterator<?> iterator = root.elementIterator("freeVisit");
|
|
while (iterator.hasNext()) {
|
Element element = (Element) iterator.next();
|
|
Iterator<?> typeIterator = element.elementIterator("type");
|
while (typeIterator.hasNext()) {
|
Element elemnet = (Element) typeIterator.next();
|
String type = elemnet.getTextTrim();
|
RouteTable.addFreeVisitResourceType(type);
|
}
|
|
Iterator<?> resourceIterator = element.elementIterator("resource");
|
while (resourceIterator.hasNext()) {
|
Element elemnet = (Element) resourceIterator.next();
|
String resource = elemnet.getTextTrim();
|
RouteTable.appendFreeVisitResource(resource);
|
}
|
|
Iterator<?> callIterator = element.elementIterator("call");
|
while (callIterator.hasNext()) {
|
Element elemnet = (Element) callIterator.next();
|
String call = elemnet.getTextTrim();
|
RouteTable.appendFreeVisitCall(call);
|
}
|
}
|
}
|
|
private static void loadRouteConfig(Element root) throws Exception {
|
Iterator<?> iterator = root.elementIterator("routes");
|
|
while (iterator.hasNext()) {
|
Element element = (Element) iterator.next();
|
|
Iterator<?> mappingIterator = element.elementIterator("route");
|
while (mappingIterator.hasNext()) {
|
Element elemnet = (Element) mappingIterator.next();
|
|
String path = elemnet.attributeValue("path");
|
String target = elemnet.attributeValue("target");
|
String className = elemnet.attributeValue("classname");
|
|
if (!Util.isEmpty(className)) {
|
ControllerConfig controllerConfig = new ControllerConfig(path, className);
|
controllerList.add(controllerConfig);
|
}
|
else if (!Util.isEmpty(target)) {
|
VirtualPathConfig virtualPath = new VirtualPathConfig(path, target, className);
|
virtualPathList.add(virtualPath);
|
}
|
}
|
}
|
}
|
|
private static void loadInitializers(Element root) throws Exception {
|
Iterator<?> iterator = root.elementIterator("initializers");
|
|
while (iterator.hasNext()) {
|
Element element = (Element) iterator.next();
|
Iterator<?> configIterator = element.elementIterator("initializer");
|
|
while (configIterator.hasNext()) {
|
Element loaderEl = (Element) configIterator.next();
|
|
String name = loaderEl.attributeValue("name");
|
String classname = loaderEl.attributeValue("classname");
|
boolean active = Translator.toBoolean(loaderEl.attributeValue("active"), true);
|
|
if (!active) {
|
logger.debug("loader not active, skip: " + name);
|
continue;
|
}
|
|
Initializer initializer = ObjectCreator.create(classname);
|
initializer.setName(name);
|
|
initializerContainer.add(initializer);
|
}
|
}
|
}
|
|
private static void createOneRoute(VirtualPathConfig virtualPath) throws Exception {
|
if (virtualPath.invalid()) {
|
return;
|
}
|
|
RouteTable.appendVirtualPath(virtualPath.getPath(), virtualPath.getTarget());
|
}
|
|
private static void createOneRoute(ControllerConfig callableConfig) throws Exception {
|
if (callableConfig.invalid()) {
|
return;
|
}
|
|
RouteTable.appendCallableClass(callableConfig.getPath(), callableConfig.getClassName());
|
}
|
|
private static void loadActiveDataSource(Element root) {
|
Element parent = root.element("datasources");
|
Iterator<?> iterator = parent.elementIterator("datasource");
|
|
while (iterator.hasNext()) {
|
Element element = (Element) iterator.next();
|
String name = element.attributeValue("name");
|
boolean active = Translator.toBoolean(element.attributeValue("active"), false);
|
|
if (!active) {
|
continue;
|
}
|
|
activeDataSourceList.add(name);
|
}
|
}
|
|
}
|
