2020年9月26日，老同学翘首以盼的自运行同学会，终于在广州香格里拉酒店举行，本期是针对广东区域的老同学，引起了很大的反响。
十一中秋双节将至，同学们能够“脱身”来到现场，足见很多企业家逐步从琐碎的管理中解放出来，离自运行的目标越来越近；为了同学们共同的理想，本届同学会也带来了一个大家很关心的主题：
如何用“机制+赋能”打造高绩效的团队？
如何持续聚焦盈利？
“ 新商业模式决定企业盈利
自运行机制服务企业盈利 ”
——戴天宇
资深设计师巩永宁在本次同学会中分享道：
“中国的企业在经历了要素驱动与投资驱动两个阶段后，开始迈进创新驱动的新境界；靠单一产品或者技术就能打天下的时代一去不返，靠一两个小点子或者一次投机就能决胜的时代也过去了，企业如何持续地盈利呢？”
巩老师
同学们回想起，戴天宇老师在以往的课堂曾经讲过，盈利模式是机制设计的起点。但企业盈利的起点又是什么呢？戴老师说，企业之所以能够盈利的本质，是因为企业能够创造价值。
因此，本期同学会巩老师，首先为老学员们讲解戴老师创立“新商业模式”；新商业模式正是深入从价值层面，在企业整个产业价值生态链中，梳理和重构企业内部的价值链组合以及商业位势，进一步引爆盈利。
巩老师的分享进一步地打通了老同学自运行知识的版图，针对老学员个性化问题，巩老师也进行一对一的解答。老同学们直叹茅塞顿开，这种形式的学习十分高效，对落地自运行的帮助很直接。
设计师以及老同学之间热烈讨论
良仕化工的周明星周总说：“以前市面上大家都听说商业模式这个词，但不知道怎么回事，也不知道怎么进行设计，但是今天听了巩老师讲商业模式，终于知道商业模式是什么，以及怎么进行优化和设计，有了一套完整的方法论。通过商业模式的梳理就能为机制设计找到企业的盈利突破口。” 
机制+赋能=员工高绩效
机制解决员工动力问题，没有机制，企业就会变成“黄埔军校”，流失优质人才。赋能解决员工能力问题，没有赋能，员工能力不够，很难自管理、自运行。所以，高绩效的团队应该既有机制也有赋能。
为此，资深设计师刘章义为老同学分享了《干部成长赋能机制》，从理论到操作，从讲解到答疑，讨论非常激烈，学员受益匪浅。
刘老师
刘老师谈到：“从管理自己到管理他人，再到管理经理人的过程，是领导能力质的飞跃。在这个过程中，要经受六次能力转型，每一次转型都是脱胎换骨。
“然而，企业基业长青，不仅是依靠人才的单打独斗，也不是依靠人才的集群效应，而是依靠正确的人才管理机制。谁拥有了正确的人才管理机制，谁就能够做到战将如云，谁就赢得未来。”
本期自运行同学会虽然只针对广东区域老，但现场干货满满，实战高效，参与的老同学们都感到意犹未尽，许多企业家提出这样的活动应该经常举办。
自运行同学会，作为推进“让员工自动自发，助老板无为而治”的系统环节之一，未来也将拓展到对全国老同学开放，期待更多的老同学的加入！

                                        
                                            
Tivoli Storage Manager (TSM) 是一个企业范围的网络存储管理应用程序。它为多供应商的工作站、个人计算机和局域网 (LAN) 
文件服务器提供了自动存储管理服务。


TSM 包括下列组件：
服务器 : 允许服务器系统为工作站提供备份、归档和空间管理服务。服务器为 TSM 资源、用户和用户数据维护数据库和恢复日志。 
服务器控制叫做存储池的存储对象。它们是存储备份文件、归档文件和空间管理文件的随机和顺序存取的介质组。可以在企业网络中设置多个服务器，以合理利用存储器、处理器和网络资源。TSM 
允许您从运行在一个 Web 浏览器（企业控制台）中的单个接口管理和控制多个服务器。 

管理界面: 允许管理员控制并监视服务器活动，定义客户机文件的管理策略并为定期提供服务设置调度。管理功能从管理客户机命令行和 Web 浏览器接口得到。 
也可以从服务器控制台得到。 

备份归档客户机: 
允许用户保留其文件的备份版本，如果原始文件丢失或毁坏可恢复这些文件。用户也可以将文件归档以长期存储文件，并在必要时检索归档文件。用户自己或管理员可以将工作站和文件服务器注册为有 
TSM 服务器的客户机节点。 

应用程序接口(API): 允许用户增强带有备份、归档、恢复和检索服务的现有应用程序。当用户在他们的工作站上安装 TSM API 
客户机时，他们可以注册为有TSM服务器的客户机节点。 

TSM 还支持下列客户机程序：
用于应用程序的 Tivoli Data Protection（应用程序客户机）：允许用户对应用程序（如数据库程序）使用的数据执行联机备份。 
在数据库启动备份或恢复后，应用程序客户机作为 TSM 的接口。此时 TSM 
服务器将存储管理功能应用于数据。应用程序客户机可以在用户正在工作时执行其功能，而中断极少。 

Tivoli Space Manager：为某些平台上的工作站提供空间管理服务。Tivoli Space Manager 
用户可以通过将不常使用的文件迁移到服务器存储器来释放工作站存储器。 
这些迁移过的文件也称为空间管理文件。用户只需按他们通常存取空间管理文件的方式就可自动重调用空间管理文件。Tivoli Space Manager 
也称作分层存储管理 (HSM) 客户机。 

图 1展示了一个带 TSM 的客户机／服务器环境的示例。 在此例中，管理员使用管理接口监视系统，例如使用安装在工作站上的管理客户机程序。 
管理员也可以通过使用有适当的 Java 支持的 Web 浏览器来监视服务器。 

通过 LAN 连接的工作站已经安装了备份归档客户机程序和 HSM 客户机程序，并注册为客户机节点。用户可以从这些客户机节点将文件备份、归档或迁移到服务器。 
通过使用分配给文件的 TSM 策略中的规则，服务器将客户机文件存储到服务器存储器中的磁盘、 光盘或磁带卷。服务器存储器被划分为许多称作存储卷组的存储池。 


图 1. 样本客户机／服务器环境

下列各章节给出了有关 TSM 的关键概念和信息。这些章节描述了 TSM 如何根据管理员定义的策略中提供的信息管理客户机文件，以及根据管理员定义的 TSM 
存储对象中提供的信息管理设备和介质。 
概念： 
"Tivoli Storage Manager 如何存储客户机数据"
"Tivoli Storage Manager 
设备支持"
"客户机操作自动化"
"使用 Tivoli Storage Manager 服务器网络" 
1、 
Tivoli Storage Manager 如何存储客户机数据 
客户机使用 TSM 存储数据以实现下列任一目的：

备份: 将客户机工作站的数据复制到服务器存储器以防止数据丢失。服务器根据策略保留文件多个版本的副本。策略包括版本号和版本的保存期。 


归档: 将客户机工作站的数据复制到服务器存储器以便长期存储。服务器根据保存期策略保留归档副本。 

空间管理: 通过用 Tivoli Space Manager 将工作站的文件复制到服务器存储器释放客户机存储器空间。该过程也叫作分层存储管理 
(HSM)。在客户机上，Tivoli Space Manager 用指向服务器中原始文件的存根文件替换原始文件。 将客户机文件移到服务器存储器的进程也称为迁移。 


TSM 策略控制如何存储和管理客户机数据。管理员通过定义策略域、策略集、管理类以及备份和归档副本组定义策略。当安装 TSM 
时，用户有一个策略，它包含一个名为 STANDARD 的策略域。STANDARD 策略域包含策略集、管理类、备份副本组和归档副本组，它们都命名为 
STANDARD。

图 2显示了策略是如何成为存储客户机数据的 TSM 进程的组成部分。 

图 2. Tivoli Storage Manager 如何控制备份、归档和迁移进程步骤如下：

客户机启动备份、归档、或迁移操作。操作中涉及的文件绑定到一个管理类。管理类可以是缺省值，也可以是在客户机的包含排除列表中为文件指定的值。 


如果文件根据管理类中的信息等待备份、归档或迁移，客户机就将该文件和文件信息发送到服务器上。 

服务器检查绑定到文件的管理类，以确定存储器目标，即服务器最初将文件所存到的TSM 存储池的名称。 
对于备份和归档文件，在管理类的备份和归档副本组中分配存储器目标。对于空间管理文件，在管理类本身中分配存储器目标。 存储池可以是一组磁盘卷、磁带卷或光盘卷。 


服务器将文件存储到标定为存储器目标的存储池。 
TSM在TSM数据库中保存有关备份、归档或迁移的每个文件的信息。此信息包括文件名、文件大小、文件所有者、管理类、副本组以及文件在TSM 服务器存储器中的位置。 
如果服务器存储器以层次结构组织，则TSM可以在以后将文件迁移到不同的存储池。例如，可能要设置服务器存储器以便TSM将磁盘存储池的文件迁移到磁带存储池中的磁带卷。 


文件保留在服务器存储器中，直到它们到期和发生到期处理，或者直到它们从服务器存储器中删除。文件到期是因为设置在策略中的标准或将文件从客户机文件系统中删除。 
2、Tivoli Storage Manager 设备支持 
Tivoli Storage Manager 用管理员所定义的下列对象表示物理存储设备和介质：

库: TSM 库就是一个或多个具有类似介质安装要求的驱动器（还可能有自动设备）。 

驱动器: 每个 TSM 驱动器代表磁带或光学设备中的一种驱动机制。 

设备类: 设备类指定了设备类型以及设备管理介质的方式，每一设备都与相应的设备类相关联。TSM 对随机存取设备有一个预定义的设备类 
(DISK)。 

存储池和卷: 存储池是介质类型相同的存储卷的有名集合。存储池与设备类关联。例如，一个8mm 磁带存储池只包含 8mm 
的磁带卷。存储池卷与特定的存储池关联。 

3、对象内容的组合 
图 3概述了物理设备环境、TSM 存储器以及策略对象和客户机之间的关系。

图 3. 系统总图

下面的列表中的数字与图中的数字相对应。

(1)当客户机注册后，它们与策略域相关联。策略域中有策略集、管理类和副本组。 

(2)、(3) 
当客户机备份、归档或迁移文件时，就与管理类连接。管理类与其内的备份和归档副本组指定将文件存到何处，以及对它们进行备份、归档或迁移（空间管理文件）时如何管理它们。 


(4)、(5) 存储池是备份文件、归档文件或空间管理文件的目的地。副本组指定备份或归档文件的存储池。管理类指定空间管理文件的存储池。 
存储池被映射为表示设备的设备类。存储池包含与设备类相关联的设备类型所指定的卷。例如，映射到设备类型为 8MM 的设备类的存储池仅包含 8mm 磁带。 
所有设备都必需有至少指定一个设备类型的设备类。磁带和光盘设备也必需有管理介质（包含介质的安装）的库和驱动器。 

(6) 如果在存储器层次结构中设置了存储池，最初存储在磁盘存储池上的文件就可以迁移到磁带或光盘存储池中。 

4、客户机操作自动化 
可以使诸如客户机备份等的操作自动化。可以立即执行操作或定期调度执行这些操作。图4显示了可能在自动客户机操作中涉及的 TSM 
对象。相互作用的关键对象是：

每个客户机上的"包含排斥"列表（UNIX 客户机的文件）: 确定备份或空间管理哪些文件，同时也确定了文件的管理类。 

管理类: 确定客户机文件最初存储的位置以及对它们如何管理

调度: 确定发生客户机操作（如备份）的时间。 

已定义的客户机和调度之间的关联: 确定为客户机运行哪些调度 

客户机可以指定文件或文件集的管理类，也可使用策略域的缺省管理类。客户机可使用客户机包含排除列表或文件中的 INCLUDE 选项来指定管理类。（请参阅在图 
4中的(A)。） 可以使用服务器上定义客户机选项集，实现客户机选项的中心控制（如 INCLUDE 和 
EXCLUDE）。在注册客户机时，可为客户机指定要使用的客户机选项集。

管理类包含一些决定 TSM 如何处理客户机备份、归档或迁移的文件的信息。 
例如，管理类包含备份副本组和归档副本组。每个副本组指向一个目标，即当备份或归档文件时最初存储文件的存储池。（请参阅在图 4中的(E)。） 

在注册客户机时，就将客户机分配到了策略域中。可自动执行客户机操作的调度也与策略域相关联。（请参阅图 4中的(C)。）要自动执行客户机操作， 
应为域定义调度。然后就可以在同一域中定义调度和客户机之间的关联。（请参阅图 4中的(B)。） 

对于要在特定客户机上运行的调度，必须打开客户机并运行客户机调度程序。 

调度的客户机操作称为事件。TSM 在 TSM 数据库中存储有关事件的信息。（请参阅在图 
4中的(D)。）例如，可以查询服务器，以确定哪些调度事件已成功完成，哪些事件运行失败。 

图 4. 自动化客户机操作
5、使用 Tivoli Storage Manager 服务器网络 
在网络中可能有大量位于相同或不同位置的 TSM 服务器。例如，可能有许多分布在不同位置的用户，并且已经找到了邻近用户的 TSM 服务器来管理网络带宽限制。 
为组织机构的目的，您可以设置多个服务器。在网络上有多个服务器，使灾难恢复更容易。TSM 提供了一些功能来帮助配置、管理和监视连接到网络的服务器。例如，工作在一个 
TSM 服务器的管理员可以处理位于世界上其它位置的 TSM 服务器，如图 5所述。 

图 5. 连接世界各地的 Tivoli Storage Manager 服务器

企业管理功能允许完成下列操作： 
从单个配置管理器对多个受管服务器进行维护和分发服务器配置信息（如策略）。 

从单个服务器监视多个服务器和客户机在一个服务器上向一个或多个其它服务器和服务器组发布命令 

使用服务器到服务器虚拟卷，可以将一个服务器的存储器用于存储另一服务器的数据。 

使用 Tivoli Disaster Recovery Manager 
(DRM)，可以在另一服务器上存储一个服务器的恢复计划文件。也可将服务器数据库和存储池备份到另一个服务器。 

			
			

			
			
                                                            

                    

                                                    来自 “ ITPUB博客 ” ，链接：http://blog.itpub.net/11134849/viewspace-615635/，如需转载，请注明出处，否则将追究法律责任。
                                            

                
转载于:http://blog.itpub.net/11134849/viewspace-615635/

很早就接触过Java在线编辑编译运行的企业应用, 感觉很NB很高端, 一晃很多年过去了...
闲来无事就自己去实现下看看. 还是有一些知识点的
1. Java 编译的功能是实现在tools.jar里边的, javac.exe只是对tools.jar里边的编译功能做了一些封装, 你要将tools.jar包放到jre/lib中去, 不然是不能编译的
2. 利用Java的类载机制来加载动态生成的 xx.class 文件
3. 利用反射来调用动态加载的 xx.class文件的 main() 方法.
4. 利用Java自带的http服务器来发送在线编辑的java源文件, 并显示在线编译运行结果.


转载请注明出处!!!


你可以在这里找到整个项目:
http://download.csdn.net/detail/david_ding/9746380



或者可以在这里找到所有源代码, 但是要自己手动创建项目
https://git.oschina.net/dingxw92/wefight/

https://git.oschina.net/dingxw92/wefight/tree/master/JavaOnlineRunner/src



代码中已经有很详尽的注释, 请看Java代码以及相应的的html页面:
1. Java代码:

package com.ding.javarun;

import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.Writer;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.InetSocketAddress;
import java.net.URI;
import java.net.URLDecoder;
import java.nio.charset.Charset;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
import java.util.Map;

import javax.tools.JavaCompiler;
import javax.tools.JavaCompiler.CompilationTask;
import javax.tools.SimpleJavaFileObject;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;

import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpHandler;
import com.sun.net.httpserver.HttpServer;

/**
 * Java online executor.
 * Your can post simple Java source code to server, compile and run it at remote server!
 * 
 * How to show result:
 * 1. put JDK/lib/tools.jar to your JDK/jre/lib folder!!!
 * 2. run the JavaSourceHttpServer.main() to start up server
 * 3. http://localhost:8080/coder
 * 4. write your java source code and submit it to server, you'll get the compile and execute result!
 * 
 * @author David Ding
 * @email dingxw92@foxmail.com
 *
 */
public class JavaSourceHttpServer {
	private static final int PORT =  8080;
	
	private static final String FLAG_RESULT = "flag_result";
	private static final String UTF8 = "utf-8";
	private static Charset UTF8_CS;
	
	private static StringBuilder HTML_WELCOME;
	private static StringBuilder HTML_EXECUTOR;

	public static void main(String[] args) throws Exception {
		Locale.setDefault(Locale.US); // set environment as English
		UTF8_CS = Charset.forName(UTF8); // set all the character code as UTF-8
		
		HTML_WELCOME = loadHtml("welcome.html"); // welcome HTML page, your can input your java source code here
		HTML_EXECUTOR = loadHtml("result.html"); // here show you the online java source execute result.

		HttpServer server = HttpServer.create(new InetSocketAddress(PORT), 0); // listening on port
		server.createContext("/coder", new WelcomeHandler()); // coder/welcome page
		server.createContext("/result", new ExecutorHandler()); // executor/result page
		server.start();

		System.out.println("********************************");
		System.out.println("**  Java HTTP server startup  **");
		System.out.println("********************************");
	}

	/**
	 * Load the template HTML page
	 * @param html file
	 * @return
	 * @throws IOException
	 */
	private static StringBuilder loadHtml(String html) throws IOException {
		File htmlFile = new File(html);
		if (!htmlFile.exists()) {
			htmlFile = new File("src/" + html);
		}
		if (!htmlFile.exists()) {
			htmlFile = new File("bin/" + html);
		}
		return readStream(new FileInputStream(htmlFile));
	}

	/**
	 * Read content from input stream
	 * @param inStream
	 * @return
	 * @throws IOException
	 */
	private static StringBuilder readStream(InputStream inStream) throws IOException {
		StringBuilder content = new StringBuilder();
		BufferedReader reader = new BufferedReader(new InputStreamReader(inStream, UTF8_CS));
		String line;
		while ((line = reader.readLine()) != null) {
			content.append(line + "\n");
		}
		reader.close();
		return content;
	}

	static class WelcomeHandler implements HttpHandler {
		final byte[] mWelcomeBytes = HTML_WELCOME.toString().getBytes(UTF8_CS);

		@Override
		public void handle(HttpExchange exchange) throws IOException {
			exchange.sendResponseHeaders(200, mWelcomeBytes.length);
			exchange.getResponseBody().write(mWelcomeBytes);
			exchange.getResponseBody().close();
		}
	}

	static class ExecutorHandler implements HttpHandler {
		final String mResultTemplateHtml = HTML_EXECUTOR.toString();

		@Override
		public void handle(HttpExchange exchange) throws IOException {
			Map<String, String> params = convertStream2Params(exchange);
			String source = params.get("java_source");
			String resultHtml = parseExecuteResult(mResultTemplateHtml, source);
			byte[] finalHtmlBytes = resultHtml.getBytes(UTF8_CS);
			exchange.sendResponseHeaders(200, finalHtmlBytes.length);
			exchange.getResponseBody().write(finalHtmlBytes);
			exchange.getResponseBody().close();
		}

	}

	/**
	 * Parse the java source code, and fill the result template HTML page
	 * @param resultHtml
	 * @param source
	 * @return
	 */
	private static String parseExecuteResult(String resultHtml, String source) {
		String className = parseClassName(source); // parse class name
		
		ByteArrayOutputStream bos = new ByteArrayOutputStream(); // the basic output stream, all the print log is here
		PrintWriter writer = new PrintWriter(bos, true);
		boolean compilerResult = compile(className, source, writer); // compile the java source file
		if (compilerResult) {
			// set the System out/err stream to get the print log
			PrintStream out = System.out;
			PrintStream err = System.err;
			PrintStream exePrintStream = new PrintStream(bos, true);
			System.setOut(exePrintStream);
			System.setErr(exePrintStream);

			try {
				Class<?> remoteClass = Class.forName(className); // load the target class
				Method main = remoteClass.getDeclaredMethod("main", String[].class); // get main method
				main.invoke(null, (Object) null); // call the main method
				exePrintStream.close();
			} catch (ClassNotFoundException | IllegalAccessException | IllegalArgumentException
					| InvocationTargetException | NoSuchMethodException | SecurityException e) {
				e.printStackTrace();
			} finally {
				// set the out/err stream back
				System.setOut(out);
				System.setErr(err);
			}
		}
		String exeLog = readPrintLog(bos);
		resultHtml = resultHtml.replaceAll(FLAG_RESULT, exeLog); // replace the result flag to the real result
		writer.close();
		return resultHtml;
	}
	
	/**
	 * In HTML, you have to replace "\r\n" and "\n" to <br /> to print a new line
	 * @param bos
	 * @return
	 */
	private static String readPrintLog(ByteArrayOutputStream bos) {
		String log = new String(bos.toByteArray(), UTF8_CS);
		log = log.replaceAll("\r\n", "<br />");
		log = log.replaceAll("\n", "<br />");
		return log;
	}
	
	/**
	 * Compile the java source and get the print log
	 * @param className
	 * @param source
	 * @param out
	 * @return
	 */
	private static boolean compile(String className, String source, Writer out) {
		JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
		StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
		StringSourceJavaObject sourceObject = new StringSourceJavaObject(className, source);
		List<StringSourceJavaObject> fileObjects = Arrays.asList(sourceObject);
		List<String> options = new LinkedList<>();
		options.add("-d"); // the compiled class files is here: -d bin
		options.add("bin");
		CompilationTask task = compiler.getTask(out, fileManager, null, options, null, fileObjects);
		return task.call();
	}
	
	/**
	 * Parse input stream to key/value pairs
	 * @param exchange
	 * @return
	 * @throws IOException
	 */
	private static Map<String, String> convertStream2Params(HttpExchange exchange) throws IOException {
		String content = readStream(exchange.getRequestBody()).toString();
		String[] paramEntries = content.split("&");
		if (paramEntries == null) {
			return null;
		}
		Map<String, String> paramMap = new HashMap<>(paramEntries.length);
		for (String paramEntry : paramEntries) {
			String[] keyValue = paramEntry.split("=");
			paramMap.put(keyValue[0], URLDecoder.decode(keyValue[1], UTF8));
		}
		return paramMap;
	}

	/**
	 * Parse the Java class name, package + class : com.xxx.Example
	 * @param content
	 * @return
	 */
	private static String parseClassName(String content) {
		String packageName = "";
		String className = null;
		int packageStart = content.indexOf("package");
		int packageEnd = content.indexOf(";", packageStart);
		if (packageStart >= 0 && packageEnd > 0) { // package name
			packageStart += "package".length();
			packageName = content.substring(packageStart, packageEnd).replace('\t', ' ').trim() + ".";
		}

		int classStart = content.indexOf("class");
		int classEnd = content.indexOf("{", classStart);
		if (classStart >= 0 && classEnd > 0) { // class name
			classStart += "class".length();
			className = content.substring(classStart, classEnd).replace('\t', ' ').trim();
		}

		return packageName + className;
	}

	/**
	 * Convert the source to Java source object
	 * 
	 * @author David Ding
	 * @email dingxw92@foxmail.com
	 *
	 */
	static class StringSourceJavaObject extends SimpleJavaFileObject {

		private String content;

		public StringSourceJavaObject(String name, String content) {
			super(URI.create("string:///" + name.replace('.', '/') + Kind.SOURCE.extension), Kind.SOURCE);
			this.content = content;
		}

		@Override
		public CharSequence getCharContent(boolean ignoreEncodingErrors) throws IOException {
			return content;
		}
	}

}


2. 欢迎页/Java源码在线编辑页, 请将该文件 ( welcome.html ) 放置在项目的src文件夹中


<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Online Java Executor</title>
</head>
<body>

<div align="center">
<br />
<form action="/result" method="post">
<label><font color="red" size="5.5">Please write down your Java code below</font></label>
<br />
<textarea name="java_source" rows="40" cols="100" οnscrοll="this.rows++;"></textarea>
<br />
<br />
<input type="submit" />
</form>
</div>
</body>
</html>


3. 在线编译运行的结果页面,  请将该文件 ( result.html ) 放置在项目的src文件夹中


<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Online Java Executor</title>
</head>
<body>

<div align="center">
<br />
<label><font color="red" size="5.5">Your code executed result:</font></label>
<br />
<br />
<br />
<div style="text-align: left; margin-left: 100px;">flag_result</div>
</div>
</body>
</html>

一、反射机制概述

Java中的一个类由若干个对象组成,Field属性对象，Method方法对象，Constructor构造器对象，Modifier修饰符对象，数据类型对象，Void对象。
反射是类的自省，通过反射可以动态获取类中的方法、属性、构造方法等。
我们以往编写的代码都是编译期代码，这些代码是提前写好，固定的代码，反射在运行期执行的代码，使用反射编写的代码中是没有具体定义那个对象的，它会根据需要在运行期自动的创建类的对象并调用相关方法。
我们可以通过反射来开发通用功能的方法或类；目前所使用所有企业级开发框架都离不开反射。

二、反射的基本使用


要使用反射必须先拿到一个类或对象的Class对象。获得一个类的class对象（字节码对象）的方式：

(1) 通过类名获得该类的字节码对象



(2)通过一个类的完整路径获得该类的字节码对象



(3)通过对象获取该对象的字节码对象




使用反射操作类中的属性

(1)获得类中的属性
 //获得一个类的字节码对象
 Class userCla = User.class;
 //获得类中的所有属性
 Field[] fields  = userCla.getDeclaredFields();
 //使用循环遍历Field数组，并获取每个属性的详情
 for(Field field : fields){
 	//获得属性名
 	String fieldName = field.getName();
 	//获得属性的类型
 	Class typeClass = field.getType();
 	//获得属性的修饰符
 	int modifier = field.getModifiers();
 	//将修饰符的数字转换为对应的字符串
 	String modifierName = Modifier.toString(modifier);
 }

(2)操作相应的属性
 Class userCla = User.class;
 //根据属性名获得属性对象
 Field field = userCla.getDeclaredField("password");
 //调用该属性
 //创建类的对象，调用无参数的构造方法创建对象
 Object obj  = userCla.newInstance();
 //调用属性设置值，指定调用哪个对象的field方法并赋值
 field.set(obj,"000000");
 //获取属性的值
 Object value = field.get(obj);



使用反射操作类中的方法

(1)获得类中的所有方法细节
 Class userCla = User.class;
 //获取类中的所有方法
 Method[ ] methods = userCla.getDeclaredMethods();
 //遍历methods数组
 for(Method method :  methods){
 	//获得方法名
 	String methodName = method.getName();
 	//获得方法的返回类型
 	Class returnType =  method.getReturnType();
 	//获得方法的修饰符
 	String modifierName =Modifier.toString(method.getModifiers());
 	//获得参数列表
 	Class [ ] params = method.getParameterTypes();
 	System.out.println(modifierName+" "+returnType+" "+methodName);
 	System.out.println("参数列表:");
 	for(Class param : params){
 		System.out.prirntln(param);
 	}
 }

(2)根据方法名和方法的参数列表获得一个方法对象，并调用该方法。
 Class userCla = User.class;
 //根据方法名和参数获得一个对象
 Method method = userCla.getDeclaredMethod("setUsername",String.class);
 //创建对象
 Object obj  = userCla.newInstance();
 //调用方法，设置username属性的值
 method.invoke(obj,"小胖");
 //获得username对象的get方法来获取username的值
 Method getMethod = userCla.getDeclaredMethod("getUsername");
 //调用方法，并返回结果
 Object objValue = getMethod.invoke(obj);
 System.out.println(objValue);



使用反射操作类中的方法

(1)获得所有构造方法
 Class userCla = User.class;
 //获取类中的所有构造方法
 Constructor [ ] constructors = userCla.getDeclaredConstructors();
 //遍历数组，获得每个构造器详情
 for(Constructor constructor : constructors){
 	//获得名字
 	String constructorName = constructor.getName();
 	//获得操作符的修饰符
 	String modifierName = Modifier.toString(constructor.getModifiers());
 	//获得参数列表
 	Class[ ]  params = constructor.getParameterTypes();
 	System.out.prirntln(modifierName+" "+constructorName);
 	System.out.println("参数 列表:");
 	for(Class param : params){
 		System.out.println(param);
 	}
 }

(2)根据参数列表获得指定的构造器并利用该构造器创建对象
 Class userCla = User.class;
 //使用无参构造创建类的对象
 Object obj  =userCla.newInstance();
 //获得带有参数的构造器
 Constructor constructor = userCla.getDeclaredConstructor(int.class,String.class,String.class);
 //利用获得的构造方法对象来创建类的对象
 Object obj1 = constructor.newInstance(10,"admin","123456");
 System.out.println(obj1);



三、使用反射封装DBUtil类中的通用查询方法