面向对象之路_getgettermethods-CSDN博客

仿struts读取配置文件，完成如下要求：

0. 读取配置文件struts.xml
1. 根据actionName找到相对应的class ，例如LoginAction, 通过反射实例化（创建对象）据parameters中的数据，调用对象的setter方法，例如parameters中的数据是 ("name"="test" , "password"="1234") , 那就应该调用 setName和setPassword方法
2. 通过反射调用对象的exectue 方法，并获得返回值，例如"success"
3. 通过反射找到对象的所有getter方法（例如 getMessage）, 通过反射来调用，把值和属性形成一个HashMap , 例如 {"message": "登录成功"} , 放到View对象的 parameters
4. 根据struts.xml中的 <result> 配置,以及execute的返回值，确定哪一个jsp，放到View对象的jsp字段中。

自己的思路不清晰，代码杂乱不堪，完全是想一点写一点。

现将刘老师TDD实现思路及面向对象大法整理如下：

public class ConfigurationTest {
Configuration cfg=new Configuration("struts.xml");
@Test
public void testGetClassName() {
String clzName=cfg.getClassName("login");
Assert.assertEquals("domain.LoginAction", clzName);

clzName = cfg.getClassName("logout");
Assert.assertEquals("domain.LogoutAction", clzName);
}
@Test
public void testResultView(){
String jsp=cfg.getResultView("login","success");
Assert.assertEquals("/jsp/homepage.jsp",jsp);
}
}

一个用来读取配置文件并将class转换成其静态内部类，然后通过静态内部类的属性对应上类名。

public class Configuration {

Map<String,ActionConfig> actions = new HashMap<>();

public Configuration(String fileName) {

String packageName = this.getClass().getPackage().getName();

packageName = packageName.replace('.', '/');

InputStream is = this.getClass().getResourceAsStream("/" + packageName + "/" + fileName);

parseXML(is);

try {
is.close();
} catch (IOException e) {
throw new ConfigurationException(e);
}
}

private void parseXML(InputStream is){

SAXBuilder builder = new SAXBuilder();

try {

Document doc = builder.build(is);

Element root = doc.getRootElement();

for(Element actionElement : root.getChildren("action")){

String actionName = actionElement.getAttributeValue("name");
String clzName = actionElement.getAttributeValue("class");

ActionConfig ac = new ActionConfig(actionName, clzName);

for(Element resultElement : actionElement.getChildren("result")){

String resultName = resultElement.getAttributeValue("name");
String viewName = resultElement.getText().trim();

ac.addViewResult(resultName, viewName);

}

this.actions.put(actionName, ac);
}

} catch (JDOMException e) {
throw new ConfigurationException(e);

} catch (IOException e) {
throw new ConfigurationException(e);

}

}

public String getClassName(String action) {
ActionConfig ac = this.actions.get(action);
if(ac == null){
return null;
}
return ac.getClassName();
}

public String getResultView(String action, String resultName) {
ActionConfig ac = this.actions.get(action);
if(ac == null){
return null;
}
return ac.getViewName(resultName);
}

private static class ActionConfig{

String name;
String clzName;
Map<String,String> viewResult = new HashMap<>();

public ActionConfig(String actionName, String clzName) {
this.name = actionName;
this.clzName = clzName;
}
public String getClassName(){
return clzName;
}
public void addViewResult(String name, String viewName){
viewResult.put(name, viewName);
}
public String getViewName(String resultName){
return viewResult.get(resultName);
}
}

}

TDD加对象的职责划分，用一个工具类来处理反射。

public class ReflectionUtilTest {

@Test
public void testGetSetterMethod() throws Exception{
String name="domain.LoginAction";
Class<?> clz=Class.forName(name);
List<Method>methods =ReflectionUtil.getSetterMethods(clz);

Assert.assertEquals(2, methods.size());

List<String> expectedNames=new ArrayList<>();
expectedNames.add("setName");
expectedNames.add("setPassword");

Set<String> acctualNames=new HashSet<>();
for(Method m:methods){
acctualNames.add(m.getName());
}
Assert.assertTrue(acctualNames.containsAll(expectedNames));
}
@Test
public void testSetParameters() throws Exception{
String name="domain.LoginAction";
Class<?>clz=Class.forName(name);
Object o=clz.newInstance();
Map<String,String>params=new HashMap<String,String>();
params.put("name", "test");
params.put("password", "1234");

ReflectionUtil.setParameters(o,params);

Field f=clz.getDeclaredField("name");
f.setAccessible(true);
Assert.assertEquals("test", f.get(o));

f=clz.getDeclaredField("password");
f.setAccessible(true);
Assert.assertEquals("1234", f.get(o));
}
@Test
public void testGetGetterMethod()throws Exception{
String name="domain.LoginAction";
Class<?>clz=Class.forName(name);
List<Method>methods=ReflectionUtil.getGetterMethods(clz);

Assert.assertEquals(3, methods.size());
List<String>expectedNames=new ArrayList<>();
expectedNames.add("getMessage");
expectedNames.add("getName");
expectedNames.add("getPassword");
Set<String> acctualNames=new HashSet<>();
for(Method m:methods){
acctualNames.add(m.getName());
}
Assert.assertTrue(acctualNames.containsAll(expectedNames));
}
@Test
public void testGetParamters() throws Exception{
String name="domain.LoginAction";
Class<?> clz=Class.forName(name);
LoginAction action=(LoginAction) clz.newInstance();
action.setName("test");
action.setPassword("123456");

Map<String,Object> params=ReflectionUtil.getParamterMap(action);
Assert.assertEquals(3, params.size());

Assert.assertEquals(null, params.get("message"));
Assert.assertEquals("test", params.get("name"));
Assert.assertEquals("123456", params.get("password"));
}
}

工具类用来封装对象的get、set方法，来对对象的属性值的射入和获取。

public class ReflectionUtil {
public static List<Method> getSetterMethods(Class<?> clz) {
return getMethods(clz, "set");
}

private static List<Method> getMethods(Class<?> clz, String startWithName) {
List<Method> methods = new ArrayList<>();
for (Method m : clz.getDeclaredMethods()) {
if (m.getName().startsWith(startWithName)) {
methods.add(m);
}
}
return methods;
}

public static void setParameters(Object o, Map<String, String> params) {
List<Method> methods = getSetterMethods(o.getClass());
for (String name : params.keySet()) {
String methodName = "set" + name;
for (Method m : methods) {
if (m.getName().equalsIgnoreCase(methodName)) {
try {
m.invoke(o, params.get(name));
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
}

public static List<Method> getGetterMethods(Class<?> clz) {
return getMethods(clz, "get");

}

public static Map<String, Object> getParamterMap(Object o) {
Map<String, Object> params = new HashMap<>();
List<Method> methods = getGetterMethods(o.getClass());
for (Method m : methods) {
String methodName = m.getName();
String name = methodName.replaceFirst("get", "").toLowerCase();
try {
Object value = m.invoke(o);
params.put(name, value);
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return params;
}

}

最后用来实现上述要求的方法简单如斯：

public class Struts {

private final static Configuration cfg = new Configuration("struts.xml");

public static View runAction(String actionName, Map<String,String> parameters) {

String clzName = cfg.getClassName(actionName);

if(clzName == null){
return null;
}
try {

Class<?> clz = Class.forName(clzName);
Object action = clz.newInstance();
ReflectionUtil.setParameters(action, parameters);
Method m = clz.getDeclaredMethod("execute");
String resultName = (String)m.invoke(action);
Map<String,Object> params = ReflectionUtil.getParamterMap(action);
String resultView = cfg.getResultView(actionName, resultName);
View view = new View();
view.setParameters(params);
view.setJsp(resultView);
return view;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}

}

附：<?xml version="1.0" encoding="UTF-8"?>
<struts>
<action name="login" class="domain.LoginAction">
<result name="success">/jsp/homepage.jsp</result>
<result name="fail">/jsp/showLogin.jsp</result>
</action>
<action name="logout" class="domain.LogoutAction">
<result name= "success">/jsp/welcome.jsp</result>
<result name= "error">/jsp/error.jsp</result>
</action>
</struts>