- 浏览: 7340148 次
- 性别:
- 来自: 上海
文章分类
- 全部博客 (1546)
- 企业中间件 (236)
- 企业应用面临的问题 (236)
- 小布Oracle学习笔记汇总 (36)
- Spring 开发应用 (54)
- IBatis开发应用 (16)
- Oracle基础学习 (23)
- struts2.0 (41)
- JVM&ClassLoader&GC (16)
- JQuery的开发应用 (17)
- WebService的开发应用 (21)
- Java&Socket (44)
- 开源组件的应用 (254)
- 常用Javascript的开发应用 (28)
- J2EE开发技术指南 (163)
- EJB3开发应用 (11)
- GIS&Mobile&MAP (36)
- SWT-GEF-RCP (52)
- 算法&数据结构 (6)
- Apache开源组件研究 (62)
- Hibernate 学习应用 (57)
- java并发编程 (59)
- MySQL&Mongodb&MS/SQL (15)
- Oracle数据库实验室 (55)
- 搜索引擎的开发应用 (34)
- 软件工程师笔试经典 (14)
- 其他杂项 (10)
- AndroidPn& MQTT&C2DM&推技术 (29)
- ActiveMQ学习和研究 (38)
- Google技术应用开发和API分析 (11)
- flex的学习总结 (59)
- 项目中一点总结 (20)
- java疑惑 java面向对象编程 (28)
- Android 开发学习 (133)
- linux和UNIX的总结 (37)
- Titanium学习总结 (20)
- JQueryMobile学习总结 (34)
- Phonegap学习总结 (32)
- HTML5学习总结 (41)
- JeeCMS研究和理解分析 (9)
最新评论
-
lgh1992314:
[u][i][b][flash=200,200][url][i ...
看看mybatis 源代码 -
尼古拉斯.fwp:
图片根本就不出来好吧。。。。。。
Android文件图片上传的详细讲解(一)HTTP multipart/form-data 上传报文格式实现手机端上传 -
ln94223:
第一个应该用排它网关吧 怎么是并行网关, 并行网关是所有exe ...
工作流Activiti的学习总结(八)Activiti自动执行的应用 -
ZY199266:
获取不到任何消息信息,请问这是什么原因呢?
ActiveMQ 通过JMX监控Connection,Queue,Topic的信息 -
xiaoyao霄:
DestinationSourceMonitor 报错 应该导 ...
ActiveMQ 通过JMX监控Connection,Queue,Topic的信息
在项目中部分方法采用反射,通过类访问类的属性,通过类反问方法,通过属性访问方法。以及常用异常的处理在等可以使用反射出处理。
public abstract class ReflectionUtils {
/**根据类和属性名称查找属性字段
* Attempt to find a {@link Field field} on the supplied {@link Class} with
* the supplied <code>name</code>. Searches all superclasses up to {@link Object}.
* @param clazz the class to introspect
* @param name the name of the field
* @return the corresponding Field object, or <code>null</code> if not found
*/
public static Field findField(Class clazz, String name) {
return findField(clazz, name, null);
}
/**根据类和属性名称查找属性字段
* Attempt to find a {@link Field field} on the supplied {@link Class} with
* the supplied <code>name</code> and/or {@link Class type}. Searches all
* superclasses up to {@link Object}.
* @param clazz the class to introspect
* @param name the name of the field (may be <code>null</code> if type is specified)
* @param type the type of the field (may be <code>null</code> if name is specified)
* @return the corresponding Field object, or <code>null</code> if not found
*/
public static Field findField(Class clazz, String name, Class type) {
Assert.notNull(clazz, "Class must not be null");
Assert.isTrue(name != null || type != null, "Either name or type of the field must be specified");
Class searchType = clazz;
while (!Object.class.equals(searchType) && searchType != null) {
Field[] fields = searchType.getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
Field field = fields[i];
if ((name == null || name.equals(field.getName()))
&& (type == null || type.equals(field.getType()))) {
return field;
}
}
searchType = searchType.getSuperclass();
}
return null;
}
/**根据属性字段和对象,设置对象的值
* Set the field represented by the supplied {@link Field field object} on
* the specified {@link Object target object} to the specified
* <code>value</code>. In accordance with
* {@link Field#set(Object, Object)} semantics, the new value is
* automatically unwrapped if the underlying field has a primitive type.
* <p>Thrown exceptions are handled via a call to
* {@link #handleReflectionException(Exception)}.
* @param field the field to set
* @param target the target object on which to set the field
* @param value the value to set; may be <code>null</code>
*/
public static void setField(Field field, Object target, Object value) {
try {
field.set(target, value);
}
catch (IllegalAccessException ex) {
handleReflectionException(ex);
throw new IllegalStateException(
"Unexpected reflection exception - " + ex.getClass().getName() + ": " + ex.getMessage());
}
}
/**根据属性字段和对象,获取的对象中字段的值
* Get the field represented by the supplied {@link Field field object} on
* the specified {@link Object target object}. In accordance with
* {@link Field#get(Object)} semantics, the returned value is
* automatically wrapped if the underlying field has a primitive type.
* <p>Thrown exceptions are handled via a call to
* {@link #handleReflectionException(Exception)}.
* @param field the field to get
* @param target the target object from which to get the field
* @return the field's current value
*/
public static Object getField(Field field, Object target) {
try {
return field.get(target);
}
catch (IllegalAccessException ex) {
handleReflectionException(ex);
throw new IllegalStateException(
"Unexpected reflection exception - " + ex.getClass().getName() + ": " + ex.getMessage());
}
}
/**根据类,方法名称和参数类型查找方法
* Attempt to find a {@link Method} on the supplied class with the supplied name
* and no parameters. Searches all superclasses up to <code>Object</code>.
* <p>Returns <code>null</code> if no {@link Method} can be found.
* @param clazz the class to introspect
* @param name the name of the method
* @return the Method object, or <code>null</code> if none found
*/
public static Method findMethod(Class clazz, String name) {
return findMethod(clazz, name, new Class[0]);
}
/**根据类,方法名称和参数类型查找方法
* Attempt to find a {@link Method} on the supplied class with the supplied name
* and parameter types. Searches all superclasses up to <code>Object</code>.
* <p>Returns <code>null</code> if no {@link Method} can be found.
* @param clazz the class to introspect
* @param name the name of the method
* @param paramTypes the parameter types of the method
* (may be <code>null</code> to indicate any signature)
* @return the Method object, or <code>null</code> if none found
*/
public static Method findMethod(Class clazz, String name, Class[] paramTypes) {
Assert.notNull(clazz, "Class must not be null");
Assert.notNull(name, "Method name must not be null");
Class searchType = clazz;
while (!Object.class.equals(searchType) && searchType != null) {
Method[] methods = (searchType.isInterface() ? searchType.getMethods() : searchType.getDeclaredMethods());
for (int i = 0; i < methods.length; i++) {
Method method = methods[i];
if (name.equals(method.getName()) &&
(paramTypes == null || Arrays.equals(paramTypes, method.getParameterTypes()))) {
return method;
}
}
searchType = searchType.getSuperclass();
}
return null;
}
/**调用方法的应用
* Invoke the specified {@link Method} against the supplied target object
* with no arguments. The target object can be <code>null</code> when
* invoking a static {@link Method}.
* <p>Thrown exceptions are handled via a call to {@link #handleReflectionException}.
* @param method the method to invoke
* @param target the target object to invoke the method on
* @return the invocation result, if any
* @see #invokeMethod(java.lang.reflect.Method, Object, Object[])
*/
public static Object invokeMethod(Method method, Object target) {
return invokeMethod(method, target, null);
}
/**调用方法的应用
* Invoke the specified {@link Method} against the supplied target object
* with the supplied arguments. The target object can be <code>null</code>
* when invoking a static {@link Method}.
* <p>Thrown exceptions are handled via a call to {@link #handleReflectionException}.
* @param method the method to invoke
* @param target the target object to invoke the method on
* @param args the invocation arguments (may be <code>null</code>)
* @return the invocation result, if any
*/
public static Object invokeMethod(Method method, Object target, Object[] args) {
try {
return method.invoke(target, args);
}
catch (Exception ex) {
handleReflectionException(ex);
}
throw new IllegalStateException("Should never get here");
}
/**
* Invoke the specified JDBC API {@link Method} against the supplied
* target object with no arguments.
* @param method the method to invoke
* @param target the target object to invoke the method on
* @return the invocation result, if any
* @throws SQLException the JDBC API SQLException to rethrow (if any)
* @see #invokeJdbcMethod(java.lang.reflect.Method, Object, Object[])
*/
public static Object invokeJdbcMethod(Method method, Object target) throws SQLException {
return invokeJdbcMethod(method, target, null);
}
/**
* Invoke the specified JDBC API {@link Method} against the supplied
* target object with the supplied arguments.
* @param method the method to invoke
* @param target the target object to invoke the method on
* @param args the invocation arguments (may be <code>null</code>)
* @return the invocation result, if any
* @throws SQLException the JDBC API SQLException to rethrow (if any)
* @see #invokeMethod(java.lang.reflect.Method, Object, Object[])
*/
public static Object invokeJdbcMethod(Method method, Object target, Object[] args) throws SQLException {
try {
return method.invoke(target, args);
}
catch (IllegalAccessException ex) {
handleReflectionException(ex);
}
catch (InvocationTargetException ex) {
if (ex.getTargetException() instanceof SQLException) {
throw (SQLException) ex.getTargetException();
}
handleInvocationTargetException(ex);
}
throw new IllegalStateException("Should never get here");
}
/**************************************************************
*
* 处理异常的方法
*
***************************************************************/
/** 使用反射处理异常的将异常信息输出但不抛出方法以外
* Handle the given reflection exception. Should only be called if
* no checked exception is expected to be thrown by the target method.
* <p>Throws the underlying RuntimeException or Error in case of an
* InvocationTargetException with such a root cause. Throws an
* IllegalStateException with an appropriate message else.
* @param ex the reflection exception to handle
*/
public static void handleReflectionException(Exception ex) {
if (ex instanceof NoSuchMethodException) {
throw new IllegalStateException("Method not found: " + ex.getMessage());
}
if (ex instanceof IllegalAccessException) {
throw new IllegalStateException("Could not access method: " + ex.getMessage());
}
if (ex instanceof InvocationTargetException) {
handleInvocationTargetException((InvocationTargetException) ex);
}
if (ex instanceof RuntimeException) {
throw (RuntimeException) ex;
}
handleUnexpectedException(ex);
}
/**
* Handle the given invocation target exception. Should only be called if
* no checked exception is expected to be thrown by the target method.
* <p>Throws the underlying RuntimeException or Error in case of such
* a root cause. Throws an IllegalStateException else.
* @param ex the invocation target exception to handle
*/
public static void handleInvocationTargetException(InvocationTargetException ex) {
rethrowRuntimeException(ex.getTargetException());
}
/**
* Rethrow the given {@link Throwable exception}, which is presumably the
* <em>target exception</em> of an {@link InvocationTargetException}.
* Should only be called if no checked exception is expected to be thrown by
* the target method.
* <p>Rethrows the underlying exception cast to an {@link RuntimeException}
* or {@link Error} if appropriate; otherwise, throws an
* {@link IllegalStateException}.
* @param ex the exception to rethrow
* @throws RuntimeException the rethrown exception
*/
public static void rethrowRuntimeException(Throwable ex) {
if (ex instanceof RuntimeException) {
throw (RuntimeException) ex;
}
if (ex instanceof Error) {
throw (Error) ex;
}
handleUnexpectedException(ex);
}
/**
* Rethrow the given {@link Throwable exception}, which is presumably the
* <em>target exception</em> of an {@link InvocationTargetException}.
* Should only be called if no checked exception is expected to be thrown by
* the target method.
* <p>Rethrows the underlying exception cast to an {@link Exception} or
* {@link Error} if appropriate; otherwise, throws an
* {@link IllegalStateException}.
* @param ex the exception to rethrow
* @throws Exception the rethrown exception (in case of a checked exception)
*/
public static void rethrowException(Throwable ex) throws Exception {
if (ex instanceof Exception) {
throw (Exception) ex;
}
if (ex instanceof Error) {
throw (Error) ex;
}
handleUnexpectedException(ex);
}
/**
* Throws an IllegalStateException with the given exception as root cause.
* @param ex the unexpected exception
*/
private static void handleUnexpectedException(Throwable ex) {
// Needs to avoid the chained constructor for JDK 1.4 compatibility.
IllegalStateException isex = new IllegalStateException("Unexpected exception thrown");
isex.initCause(ex);
throw isex;
}
/**
* Determine whether the given method explicitly declares the given exception
* or one of its superclasses, which means that an exception of that type
* can be propagated as-is within a reflective invocation.
* @param method the declaring method
* @param exceptionType the exception to throw
* @return <code>true</code> if the exception can be thrown as-is;
* <code>false</code> if it needs to be wrapped
*/
public static boolean declaresException(Method method, Class exceptionType) {
Assert.notNull(method, "Method must not be null");
Class[] declaredExceptions = method.getExceptionTypes();
for (int i = 0; i < declaredExceptions.length; i++) {
Class declaredException = declaredExceptions[i];
if (declaredException.isAssignableFrom(exceptionType)) {
return true;
}
}
return false;
}
/*************************************************************
*
*
* 判断方法,属性字段等的修饰符的方法
*************************************************************/
/**
* Determine whether the given field is a "public static final" constant.
* @param field the field to check
*/
public static boolean isPublicStaticFinal(Field field) {
int modifiers = field.getModifiers();
return (Modifier.isPublic(modifiers) && Modifier.isStatic(modifiers) && Modifier.isFinal(modifiers));
}
/**
* Determine whether the given method is an "equals" method.
* @see java.lang.Object#equals
*/
public static boolean isEqualsMethod(Method method) {
if (method == null || !method.getName().equals("equals")) {
return false;
}
Class[] paramTypes = method.getParameterTypes();
return (paramTypes.length == 1 && paramTypes[0] == Object.class);
}
/**
* Determine whether the given method is a "hashCode" method.
* @see java.lang.Object#hashCode
*/
public static boolean isHashCodeMethod(Method method) {
return (method != null && method.getName().equals("hashCode") &&
method.getParameterTypes().length == 0);
}
/**
* Determine whether the given method is a "toString" method.
* @see java.lang.Object#toString()
*/
public static boolean isToStringMethod(Method method) {
return (method != null && method.getName().equals("toString") &&
method.getParameterTypes().length == 0);
}
/** 判断一个属性是否可以访问的方法
* Make the given field accessible, explicitly setting it accessible if necessary.
* The <code>setAccessible(true)</code> method is only called when actually necessary,
* to avoid unnecessary conflicts with a JVM SecurityManager (if active).
* @param field the field to make accessible
* @see java.lang.reflect.Field#setAccessible
*/
public static void makeAccessible(Field field) {
if (!Modifier.isPublic(field.getModifiers()) ||
!Modifier.isPublic(field.getDeclaringClass().getModifiers())) {
field.setAccessible(true);
}
}
/** 判断一个方法是否可以访问的方法
* Make the given method accessible, explicitly setting it accessible if necessary.
* The <code>setAccessible(true)</code> method is only called when actually necessary,
* to avoid unnecessary conflicts with a JVM SecurityManager (if active).
* @param method the method to make accessible
* @see java.lang.reflect.Method#setAccessible
*/
public static void makeAccessible(Method method) {
if (!Modifier.isPublic(method.getModifiers()) ||
!Modifier.isPublic(method.getDeclaringClass().getModifiers())) {
method.setAccessible(true);
}
}
/** 判断一个构造函数是否可以访问的方法
* Make the given constructor accessible, explicitly setting it accessible if necessary.
* The <code>setAccessible(true)</code> method is only called when actually necessary,
* to avoid unnecessary conflicts with a JVM SecurityManager (if active).
* @param ctor the constructor to make accessible
* @see java.lang.reflect.Constructor#setAccessible
*/
public static void makeAccessible(Constructor ctor) {
if (!Modifier.isPublic(ctor.getModifiers()) ||
!Modifier.isPublic(ctor.getDeclaringClass().getModifiers())) {
ctor.setAccessible(true);
}
}
/**
* Perform the given callback operation on all matching methods of the
* given class and superclasses.
* <p>The same named method occurring on subclass and superclass will
* appear twice, unless excluded by a {@link MethodFilter}.
* @param targetClass class to start looking at
* @param mc the callback to invoke for each method
* @see #doWithMethods(Class, MethodCallback, MethodFilter)
*/
public static void doWithMethods(Class targetClass, MethodCallback mc) throws IllegalArgumentException {
doWithMethods(targetClass, mc, null);
}
/**
* Perform the given callback operation on all matching methods of the
* given class and superclasses.
* <p>The same named method occurring on subclass and superclass will
* appear twice, unless excluded by the specified {@link MethodFilter}.
* @param targetClass class to start looking at
* @param mc the callback to invoke for each method
* @param mf the filter that determines the methods to apply the callback to
*/
public static void doWithMethods(Class targetClass, MethodCallback mc, MethodFilter mf)
throws IllegalArgumentException {
// Keep backing up the inheritance hierarchy.
do {
Method[] methods = targetClass.getDeclaredMethods();
for (int i = 0; i < methods.length; i++) {
if (mf != null && !mf.matches(methods[i])) {
continue;
}
try {
mc.doWith(methods[i]);
}
catch (IllegalAccessException ex) {
throw new IllegalStateException(
"Shouldn't be illegal to access method '" + methods[i].getName() + "': " + ex);
}
}
targetClass = targetClass.getSuperclass();
}
while (targetClass != null);
}
/**获取类的所有的方法的
* Get all declared methods on the leaf class and all superclasses.
* Leaf class methods are included first.
*/
public static Method[] getAllDeclaredMethods(Class leafClass) throws IllegalArgumentException {
final List list = new ArrayList(32);
doWithMethods(leafClass, new MethodCallback() {
public void doWith(Method method) {
list.add(method);
}
});
return (Method[]) list.toArray(new Method[list.size()]);
}
/**调用字段时执行的回调的方法
* Invoke the given callback on all fields in the target class,
* going up the class hierarchy to get all declared fields.
* @param targetClass the target class to analyze
* @param fc the callback to invoke for each field
*/
public static void doWithFields(Class targetClass, FieldCallback fc) throws IllegalArgumentException {
doWithFields(targetClass, fc, null);
}
/**调用字段时执行的回调的并过滤的方法
* Invoke the given callback on all fields in the target class,
* going up the class hierarchy to get all declared fields.
* @param targetClass the target class to analyze
* @param fc the callback to invoke for each field
* @param ff the filter that determines the fields to apply the callback to
*/
public static void doWithFields(Class targetClass, FieldCallback fc, FieldFilter ff)
throws IllegalArgumentException {
// Keep backing up the inheritance hierarchy.
do {
// Copy each field declared on this class unless it's static or file.
Field[] fields = targetClass.getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
// Skip static and final fields.
if (ff != null && !ff.matches(fields[i])) {
continue;
}
try {
fc.doWith(fields[i]);
}
catch (IllegalAccessException ex) {
throw new IllegalStateException(
"Shouldn't be illegal to access field '" + fields[i].getName() + "': " + ex);
}
}
targetClass = targetClass.getSuperclass();
}
while (targetClass != null && targetClass != Object.class);
}
/**用于对象的拷贝的方法(类必须是同一类或子类)
* Given the source object and the destination, which must be the same class
* or a subclass, copy all fields, including inherited fields. Designed to
* work on objects with public no-arg constructors.
* @throws IllegalArgumentException if the arguments are incompatible
*/
public static void shallowCopyFieldState(final Object src, final Object dest) throws IllegalArgumentException {
if (src == null) {
throw new IllegalArgumentException("Source for field copy cannot be null");
}
if (dest == null) {
throw new IllegalArgumentException("Destination for field copy cannot be null");
}
if (!src.getClass().isAssignableFrom(dest.getClass())) {
throw new IllegalArgumentException("Destination class [" + dest.getClass().getName() +
"] must be same or subclass as source class [" + src.getClass().getName() + "]");
}
doWithFields(src.getClass(), new FieldCallback() {
public void doWith(Field field) throws IllegalArgumentException, IllegalAccessException {
makeAccessible(field);
Object srcValue = field.get(src);
field.set(dest, srcValue);
}
}, COPYABLE_FIELDS);
}
/**
* Action to take on each method.
*/
public static interface MethodCallback {
/**
* Perform an operation using the given method.
* @param method the method to operate on
*/
void doWith(Method method) throws IllegalArgumentException, IllegalAccessException;
}
/**
* Callback optionally used to method fields to be operated on by a method callback.
*/
public static interface MethodFilter {
/**
* Determine whether the given method matches.
* @param method the method to check
*/
boolean matches(Method method);
}
/**
* Callback interface invoked on each field in the hierarchy.
*/
public static interface FieldCallback {
/**
* Perform an operation using the given field.
* @param field the field to operate on
*/
void doWith(Field field) throws IllegalArgumentException, IllegalAccessException;
}
/**
* Callback optionally used to filter fields to be operated on by a field callback.
*/
public static interface FieldFilter {
/**
* Determine whether the given field matches.
* @param field the field to check
*/
boolean matches(Field field);
}
/**
* Pre-built FieldFilter that matches all non-static, non-final fields.
*/
public static FieldFilter COPYABLE_FIELDS = new FieldFilter() {
public boolean matches(Field field) {
return !(Modifier.isStatic(field.getModifiers()) ||
Modifier.isFinal(field.getModifiers()));
}
};
}
发表评论
-
【转】在项目中使用多个数据源-多sessionFactory方案
2013-05-10 16:30 3131适用范围:适合SSH架构访问多个数据库, ... -
【转】使用spring的动态路由实现数据库负载均衡
2013-03-17 22:57 3309使用spring的动态路由实现数据库负载均衡 系统中 ... -
【转】spring 数据库读写分离
2013-03-17 22:56 2805什么是数据库的读写分离 数据库的读写分离简单的说是把对数据 ... -
[转]Spring+iBatis+JOTM实现JTA事务
2013-03-17 22:51 3059Spring+iBatis+JOTM实现JTA事务 ... -
Spring 和Axis2整合相关那些事
2012-12-29 12:58 10421Axis2优劣: 现在用axis2开发一个webse ... -
【转】JAVA并发容器代码随读
2012-12-06 15:29 2954转载自 http://rdc.taobao.c ... -
Spring3.04和Junit4
2011-11-27 18:15 4396在Spring3.x以上必须采用 ... -
Spring加载属性文件的扩展
2011-08-22 12:21 3026在项目中一个属性文件配置信息,提供给数据连接信息 ... -
Brap和Spring整合(简单权限验证)
2011-07-26 10:31 1390在使用Spring的发 ... -
Quartz的任务的临时启动和暂停和恢复
2011-07-16 10:18 40227在项目中需要手动启停某些服务,那么需要有一个控 ... -
Quartz中定时调度EJB3.0服务
2011-07-13 22:25 2938在quartz2.0中只支持EJb2.0的服务 ... -
Quartz中定时调度EJB2.0服务
2011-07-13 22:12 2181在Quartz2.0中提供支持EJB2.0 ... -
Quartz的简单使用
2011-07-13 22:05 9956最近工作需要学习quartz,那么必须首先了解三个概念:调度器 ... -
Brap 远程访问调用 和Spring整合(二)
2010-12-08 14:52 2006Brap和 Spring 整合使用如 ... -
闲着没事Hessian开发WebService的总结(二)
2010-12-07 20:30 4034在Spring和Hessian整合中,以前 ... -
Spring JMX的学习总结(三) 基于注释的JMX的使用
2010-12-03 17:26 3362具体实现JMX的注释的类: package c ... -
Spring JMX的总结学习(二) 注解实现MBean
2010-12-03 17:24 6284本文采用Spring JMX ... -
Spring JMX的总结学习(一)基于标准接口的JMX
2010-12-03 17:21 3781在Spring中采用JMX标准形式的,开发相关的Spr ... -
Spring JMS的开发应用--自定义消息转换器的使用(四)
2010-12-03 01:37 2511在Spring JMS、中可以通过实现Me ... -
Spring JBOSSMQ JMS的开发应用(三)
2010-11-30 20:11 2345如果用过JMS的话,会发现它类似写JD ...
相关推荐
这个"spring类库"包含的资源可以帮助开发者快速搭建基于Spring的项目环境。以下是对Spring框架及其核心组件的详细解释。 Spring框架的核心在于IoC(Inversion of Control,控制反转)和AOP(Aspect-Oriented ...
以上就是Spring应用必须的一些类库,它们共同构建了一个强大的框架,为开发者提供了灵活、高效和可扩展的解决方案。在实际项目中,根据需求选择合适的模块组合,可以大大提升开发效率和代码质量。
本来想大家把类库自己加进去就好了, fangchaojun5网友说自己怎么也跑不起来,所以在此又把为库传了上来,把这个lib解压后覆盖掉原来的lib目录就OK了,谢谢大家支持,也更应该感谢 fangchaojun5这位网友提出来,在此表示...
Java反射工具类ReflectionUtils是Java开发中常用的一个辅助类,它可以帮助开发者在运行时检查类、接口、字段和方法的信息,以及动态调用方法和访问字段。反射在Java编程中扮演着重要的角色,特别是在框架开发、插件...
Spring框架所需要的开发类库
总之,这份"一个java常用类库的源代码"资源对于Java程序员来说是一份宝藏。通过研究源码,不仅可以巩固基础,还能了解和学习到最新的编程技术和设计理念,从而提高编程效率和软件质量。无论是初学者还是经验丰富的...
在IT行业中,Spring和Mybatis是两个非常重要的Java框架,它们在企业级应用开发中扮演着核心角色。本文将深入探讨这两个框架以及相关的类库,帮助开发者更好地理解和使用它们。 首先,Spring框架是一个全面的企业级...
在"lib"压缩包中,可能包含了上述类库的JAR文件,这些都是开发Java Web应用时常用的依赖。在实际项目中,开发者会将这些JAR添加到项目的类路径中,以便在代码中引用并使用它们的功能。合理选择和使用这些类库,可以...
1. **spring-core**:这是Spring框架的基础,包含了核心工具类和反射机制。 2. **spring-beans**:负责bean的定义、实例化、配置和管理。 3. **spring-context**:扩展了spring-beans,提供了一个上下文环境,可以...
Spring框架为了进一步简化反射操作,引入了一个专门的工具类——`ReflectionUtils`。这个工具类不仅简化了Java标准库中`java.lang.reflect`包的使用,还提供了一系列高级功能,使得开发者能够更加高效地进行反射操作...
在这个特定的"spring IOC反射装载bean"的主题中,我们将深入探讨Spring如何通过XML配置文件来加载和管理Bean,并利用Java的反射机制来实例化这些Bean。 首先,Spring容器通过读取XML配置文件来获取Bean的定义。这些...
【标题】"Hibernate Spring Struts 类库 完全版(1)" 提供的是一个集成开发环境,包含三个核心的Java EE框架:Hibernate、Spring和Struts。这三大框架是企业级应用开发中的常用工具,它们各自负责不同的职责,协同...
commons-logging-1.1.jar
例如,Spring通过反射读取类的定义,查找标注了@Autowired的字段或方法,然后自动注入对应的依赖。同时,Spring还提供了基于XML、Java配置以及基于注解的配置方式,来定义对象及其依赖关系。 关于Java反射的实例,...
Java反射和Spring IOC是Java开发中的两个重要概念,它们在构建灵活、可扩展的应用程序时起着关键作用。本文将深入探讨这两个主题,并提供相关的学习资源。 首先,让我们了解一下Java反射。Java反射机制是Java语言的...
这套课程既可以作为从零基础开始...课程的主要内容涉及有JAVA基础课程、JAVA多线程与并发编程、数据库开发基础和进阶、Spring Framework、Spring进阶、Spring MVC框架、Spring boot、Java常用类库、Java异常处理等等
本压缩包包含了一些Java环境下进行Ajax编程常用的类库,下面将详细介绍这些类库及其在Ajax开发中的作用。 1. dom4j:这是一个Java的XML处理库,提供了丰富的API来读取、写入、修改和操作XML文档。在Ajax中,dom4j...
模拟Spring的依赖注入,我们可以创建一个简单的容器类,它使用反射来扫描带有特定注解的类,并根据这些注解管理bean。以下步骤概括了这个过程: 1. **定义注解**:创建自定义注解,如`@MyComponent`,用于标记需要...
例如,可能会有一个自定义的MyBatis拦截器用于分页查询,一个Spring AOP切面用于记录操作日志,Spring事务管理确保数据的一致性,而反射工具类可能用于动态加载配置或处理某些通用的反射任务。通过这些组件的组合,...
在这个案例中,提供的压缩包文件名为"spring3.0.1",这表明这是Spring框架3.0.1版本的类库,这个版本相对较老,但依然可以用于学习和理解Spring的基本概念。 在实际项目开发中,我们通常使用构建工具(如Maven或...