- 浏览: 234300 次
- 性别:
- 来自: 上海
文章分类
最新评论
-
清林小篆:
引用[/col[size=xx-small][/size]or ...
tomcat ssl配置以及CAS单点登录探究 -
cyxy99:
u012534143 写道我用同样的方法,同样的节点关系,为什 ...
PageRank算法java实现版本 -
cyxy99:
schaha123 写道楼主还有一个问题想请教一下,下面这2段 ...
PageRank算法java实现版本 -
njthnet:
Participle 和 IkParticiple 这2个类找 ...
贝叶斯文本分类 java实现 -
u012534143:
我用同样的方法,同样的节点关系,为什么的得到的结果与您不一样呢 ...
PageRank算法java实现版本
注解注入
我们知道,Spring只有一个角色:工厂。这个工厂可以生产出任何你想要的对象或依赖,并且在出厂前后可以无限制的增强功能。
Spring最基础的功能就是注入,其中注解注入的方式消除了文件配置的繁琐,让人爱不释手。我们做的这个小框架虽然没法完全依照
它的实现,但是我们可以发挥小而精的特色,做好同样的功能。
首先新建注入注解Autowired
只有一个参数,提供实现类。
接着创建容器BeanContainer,这个容器需要实现读取目标类被注解@Autowired注释的元素,提供注入功能,并且能缓存所有注入类。
处理Autowired注解的过程比较简单:读取Autowire,提取iocClass,实例化一个iocClass对象,通过反射调用setter方法,完成注入
AutowiredSet方法是此代码体的最外围方法体,里面进行了递归调用,实现了被注入类以下所有Autowired属性的注入。
单例注解
我们往往用单例模式来保证每个应用程序只产生一个某类的对象,但是用容器做单例不同于编程式单例模式,前者依赖与容器的缓存功能,后者通过约束构造方法为私有来实现,不要弄混淆哦。
首先创建单例注解:
没有任何参数属性,仅仅用来标识此类是否单例。
在容器类BeanContainer创建Map
BeanContainer设计成单例,ConcurrentHashMap可以保证多线程下的线程安全问题,当然 用HashTable也可以。
改造上面代码,加入两句话:
checkSingle用来判断是否用了单例注解
OK,就这么简单。
上面的注解注入仅仅完成了最基本的功能,还不能无缝的增强原有功能,比如现在有个需求:为特定方法做日志处理,怎么办?每个方法都加上logger?显然不是,最理想的就是
可以直接为这个事务处理类提供功能扩展,并且不影响原有代码。代理模式正是为此类问题而生的。
代理模式
伟大的Spring是设计模式运用的最佳实践,包含工厂模式,代理模式,策略模式,单例模式等等。
而代理模式的运用更是让spring框架充满活力,
毫不夸张的说,正是代理模式的运用让spring看起来无比强大。spring提供两种方式实现代理:jdk动态代理,CGLIB包。
代理模式有这样几个小概念:抽象接口,代理实现类,真实实现类。前者是后面两个的公共接口,是暴露给最终调用者的唯一接口。
首先我们模拟一下代理模式的简单例子。
1,创建抽象接口:
2,创建真实实现类,实现UserService接口:
3,创建代理实现类,实现UserService接口:
4,创建客户端测试代码:
最终输出:
事务开始
插入用户
事务提交。
当调用save方法时,会调用最终实现类的save方法,并且让你有机会在方法前后进行代码增强。
想做出通用点的代理实现 显然上面的用法是不够的。为了重现代码改造的过程,我先稍微改动一下上面的代码,
UserServiceProxy类添加一个构造方法:
调用代码改为:
新加的构造方法看起来像一个工厂,外面传入不同实现类,都可以做代理。但是这样有两个明显的缺点:
1,代理工厂需要实现所有接口方法,当方法很多时,你会感到很毛的。
2,当你需要为另一个接口做代理时,需要重新写一个Proxy,并且工厂代码一句也不能少。
你要知道我们面对的是刁钻的程序员们,他们总是不能忍受编写冗余的代码。
从JDK1.3开始,java提供了InvocationHandler接口和Proxy类,用于创建动态代理。
jdk动态代理的强制条件:实现类必须实现一个或多个接口(CGLIB包就没有此限制)
InvocationHandler只提供一个方法
public Object invoke (Object proxy, Method method, Object[] args)。
当抽象接口调用方法时,会自动调用invoke里面的方法,给我们机会diy任何附加功能。
为了把工厂代码隐藏起来,并且能够很方便的扩展,我们需要设计一个代理工厂,这个工厂的具体设计目标是:
1,提供统一的工厂方法生成代理对象,比如通过传入原始类,或者其他参数,让工厂自动创造出代理类。
2,扩展不同的代理工厂时,可以很方便的提供加工代码。
一般做法是:
1,定义工厂公共接口,继承InvocationHandler接口
ProxyFactory提供工厂方法factory,也继承了调用方法invoke。表明实现此接口可以完成创造代理类,并添加代理功能,
params是为了满足有些特殊的传参需求。
2,提供一个默认的代理工厂实现,最好满足大部分需求,再次看到常用的缺省模式。
这里有几点值得注意,首先把此类设成abstract是因为,工厂方法factory是所有工厂的共通代码,再没有抽象的必要,所以实现之,而从ProxyFactory中获得的
invoke方法是对每个工厂都需要有不同的实现,所以继续抽象之。
另外,Factory方法中的代码按常理说,可以直接用下面的几句话搞定
但是我这为了保证 即使出现一些类的层级比较复杂的情况下也能很好的生成代理类,把类的父类以上接口都纳入进来。
3,通过继承DefaultProxyFactory,实现自己的代理工厂。接下来我们一起实现一个日志处理的代理。
这个代理实现的功能是,在被代理方法前执行相应的日志输出,通过一个参数配置受控方法。
首先创建DaoLogProxy继承DefaultProxyFactory:
,这里我们通过自己的逻辑判断拦截方法。
然后写测试代码:
非常方便,控制台显示如下信息表示成功:
2012-8-21 16:44:45 java.util.logging.LogManager$RootLogger log
信息: 执行class java.util.ArrayList的add方法,参数为test0
2012-8-21 16:44:45 java.util.logging.LogManager$RootLogger log
信息: 执行class java.util.ArrayList的get方法,参数为0
假如你是客户端程序员,你期望怎样的代理配置?
我的期望是:本框架为注入类提供一个注解,配置代理工厂,让容器读取注解信息,调用工厂代码生成代理类,然后注入,这样我的客户端接口调用
的任何方法都会被自己扩展的代理类拦截。
好吧,新建Proxy注解,
注解的目标“客户”是类(Type)。proxyFactoryClass强制规定提供的代理工厂实现ProxyFactory接口,这里我们可以继承DefaultProxyFactory就ok了。
打开容器类BeanContainer,加上Proxy处理代码
最后直接注入setObject到目标对象就行了。
测试一下:
1,创建一个测试接口UserService,UserServiceImpl实现接口,并用@Proxy注释
2,在action里面配置自动注入:
并给出setter方法。
3,配置Action,调用save方法,会打印出
执行class $Proxy9的save方法。
有了Proxy注解,以后任何人想扩展自己的代理将易如反掌
具体实现代码请参考源码。
By 阿飞哥 转载请说明
腾讯微博:http://t.qq.com/duyunfeiRoom
新浪微博:http://weibo.com/u/1766094735
原文地址:http://duyunfei.iteye.com/blog/1773721
我们知道,Spring只有一个角色:工厂。这个工厂可以生产出任何你想要的对象或依赖,并且在出厂前后可以无限制的增强功能。
Spring最基础的功能就是注入,其中注解注入的方式消除了文件配置的繁琐,让人爱不释手。我们做的这个小框架虽然没法完全依照
它的实现,但是我们可以发挥小而精的特色,做好同样的功能。
首先新建注入注解Autowired
@Retention(RetentionPolicy.RUNTIME) @Target(ElementType.FIELD ) public @interface Autowired { /** * 注入依赖的类 必须为可以实例化的类 * 不能是抽象类或者接口 * @return */ public Class iocClass(); }
只有一个参数,提供实现类。
接着创建容器BeanContainer,这个容器需要实现读取目标类被注解@Autowired注释的元素,提供注入功能,并且能缓存所有注入类。
处理Autowired注解的过程比较简单:读取Autowire,提取iocClass,实例化一个iocClass对象,通过反射调用setter方法,完成注入
for (Field f : fields) { // 循环判断是否有Autowired的自动注入field Autowired au = f.getAnnotation(Autowired.class ); //System.out.println("========================="+f.getName()+" : "+au+"======================\n"); if (au != null) { // 假如此属性被注解为Autowired // 得到需要注入的实例class Class ioc = au.iocClass(); // 构造set方法 String setName = "set" + f.getName().substring(0, 1).toUpperCase() + f.getName().substring(1); // 得到action set的方法以及它的参数类型,注意此时不能是参数子类的类型。 Method setMethod = cls.getMethod(setName, new Class[] { f .getType() }); Object iocObj = ioc.newInstance(); System. out.println( "处理" + ioc.getName()); AutowiredSet(iocObj); Object setObject = iocObj; setMethod.invoke(obj, setObject); } }
AutowiredSet方法是此代码体的最外围方法体,里面进行了递归调用,实现了被注入类以下所有Autowired属性的注入。
单例注解
我们往往用单例模式来保证每个应用程序只产生一个某类的对象,但是用容器做单例不同于编程式单例模式,前者依赖与容器的缓存功能,后者通过约束构造方法为私有来实现,不要弄混淆哦。
首先创建单例注解:
@Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE ) public @interface SingleTon { }
没有任何参数属性,仅仅用来标识此类是否单例。
在容器类BeanContainer创建Map
private static Map< String, Object> autoObjMap = new ConcurrentHashMap<String, Object>();
BeanContainer设计成单例,ConcurrentHashMap可以保证多线程下的线程安全问题,当然 用HashTable也可以。
改造上面代码,加入两句话:
if (autoObjMap .containsKey(ioc.getName())) { System. out.println( "已在缓存中找到" + ioc.getName()); iocObj=getBean(ioc.getName()); setMethod.invoke(obj, iocObj); continue; } if (checkSingle(iocObj)) { autoObjMap.put(iocObj.getClass().getName(), setObject); }
checkSingle用来判断是否用了单例注解
public boolean checkSingle(Object obj) { SingleTon single = obj.getClass().getAnnotation(SingleTon .class); if (single == null) { return false; } return true; }
OK,就这么简单。
上面的注解注入仅仅完成了最基本的功能,还不能无缝的增强原有功能,比如现在有个需求:为特定方法做日志处理,怎么办?每个方法都加上logger?显然不是,最理想的就是
可以直接为这个事务处理类提供功能扩展,并且不影响原有代码。代理模式正是为此类问题而生的。
代理模式
伟大的Spring是设计模式运用的最佳实践,包含工厂模式,代理模式,策略模式,单例模式等等。
而代理模式的运用更是让spring框架充满活力,
毫不夸张的说,正是代理模式的运用让spring看起来无比强大。spring提供两种方式实现代理:jdk动态代理,CGLIB包。
代理模式有这样几个小概念:抽象接口,代理实现类,真实实现类。前者是后面两个的公共接口,是暴露给最终调用者的唯一接口。
首先我们模拟一下代理模式的简单例子。
1,创建抽象接口:
public interface UserService { public void save (); }
2,创建真实实现类,实现UserService接口:
public class UserServiceImpl implements UserService { @Override public void save() { System. out.println( "插入用户"); } }
3,创建代理实现类,实现UserService接口:
public class UserServiceProxy implements UserService { private UserService userService; public UserServiceProxy(){ //创建真实实现类 userService= new UserServiceImpl(); } @Override public void save() { System. out.println( "事务开始"); userService.save(); System. out.println( "事务提交"); } }
4,创建客户端测试代码:
public class ClientMain { public static void main(String[] args) { UserService userService= new UserServiceProxy(); userService.save(); } }
最终输出:
事务开始
插入用户
事务提交。
当调用save方法时,会调用最终实现类的save方法,并且让你有机会在方法前后进行代码增强。
想做出通用点的代理实现 显然上面的用法是不够的。为了重现代码改造的过程,我先稍微改动一下上面的代码,
UserServiceProxy类添加一个构造方法:
public UserServiceProxy(String realclass){ try { userService=(UserService)Class. forName(realclass).newInstance(); } catch (Exception e) { e.printStackTrace(); } }
调用代码改为:
UserService userService= new UserServiceProxy("com.javapatterns.proxy.mytest.UserServiceImpl" ); userService.save();
新加的构造方法看起来像一个工厂,外面传入不同实现类,都可以做代理。但是这样有两个明显的缺点:
1,代理工厂需要实现所有接口方法,当方法很多时,你会感到很毛的。
2,当你需要为另一个接口做代理时,需要重新写一个Proxy,并且工厂代码一句也不能少。
你要知道我们面对的是刁钻的程序员们,他们总是不能忍受编写冗余的代码。
从JDK1.3开始,java提供了InvocationHandler接口和Proxy类,用于创建动态代理。
jdk动态代理的强制条件:实现类必须实现一个或多个接口(CGLIB包就没有此限制)
InvocationHandler只提供一个方法
public Object invoke (Object proxy, Method method, Object[] args)。
当抽象接口调用方法时,会自动调用invoke里面的方法,给我们机会diy任何附加功能。
为了把工厂代码隐藏起来,并且能够很方便的扩展,我们需要设计一个代理工厂,这个工厂的具体设计目标是:
1,提供统一的工厂方法生成代理对象,比如通过传入原始类,或者其他参数,让工厂自动创造出代理类。
2,扩展不同的代理工厂时,可以很方便的提供加工代码。
一般做法是:
1,定义工厂公共接口,继承InvocationHandler接口
/** * 代理工厂总接口 * 所有自定义代理工厂必须实现此接口 * @author 杜云飞 * */ public interface ProxyFactory extends InvocationHandler { public Object factory(Object targetObject,Object params); public Object getTargetObject(); public Object getParams(); }
ProxyFactory提供工厂方法factory,也继承了调用方法invoke。表明实现此接口可以完成创造代理类,并添加代理功能,
params是为了满足有些特殊的传参需求。
2,提供一个默认的代理工厂实现,最好满足大部分需求,再次看到常用的缺省模式。
/** * 默认的代理工厂,假如可以扩展,继承之,实现自己的invoke方法即可 * @author duyunfei * */ public abstract class DefaultProxyFactory implements ProxyFactory { private Object params; private Object targetObject; public Object factory(Object targetObject,Object params) { this. targetObject=targetObject; this. params=params; Class cls = targetObject.getClass(); //用set的原因是,接口列表不能重复 Set<Class> listInterfaces =new HashSet<Class>(); Class[] selfInterfaces=cls.getInterfaces(); for(Class inter:selfInterfaces){ listInterfaces.add(inter); } Class superClass=cls.getSuperclass(); while(!superClass.getName().equals( "java.lang.Object")){ selfInterfaces=superClass.getInterfaces(); for(Class inter:selfInterfaces){ listInterfaces.add(inter); } superClass=superClass.getSuperclass(); } selfInterfaces=listInterfaces.toArray(selfInterfaces); return Proxy.newProxyInstance(cls.getClassLoader(), selfInterfaces, this); } public Object getTargetObject() { return targetObject; } public Object getParams() { return params; } }
这里有几点值得注意,首先把此类设成abstract是因为,工厂方法factory是所有工厂的共通代码,再没有抽象的必要,所以实现之,而从ProxyFactory中获得的
invoke方法是对每个工厂都需要有不同的实现,所以继续抽象之。
另外,Factory方法中的代码按常理说,可以直接用下面的几句话搞定
Class cls = targetObject.getClass(); Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(), this);
但是我这为了保证 即使出现一些类的层级比较复杂的情况下也能很好的生成代理类,把类的父类以上接口都纳入进来。
3,通过继承DefaultProxyFactory,实现自己的代理工厂。接下来我们一起实现一个日志处理的代理。
这个代理实现的功能是,在被代理方法前执行相应的日志输出,通过一个参数配置受控方法。
首先创建DaoLogProxy继承DefaultProxyFactory:
public class DaoLogProxy extends DefaultProxyFactory { private static Logger log = Logger. getLogger(""); public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { String params=(String) this.getParams(); String[] param=params.split( ":"); String[] includeMethods=param[1].split( ","); boolean isInclude= false; for(String inmethod:includeMethods){ if(method.getName().equals(inmethod)){ isInclude= true; } } Object returnValue= null; if(isInclude){ //是属于包含的方法 String showargs= ""; for(Object arg:args){ showargs=showargs+arg+ " "; } log .info("执行"+ this.getTargetObject().getClass()+ "的"+method.getName()+"方法,参数为" +showargs); returnValue=method.invoke( this.getTargetObject(), args); } else{ returnValue=method.invoke( this.getTargetObject(), args); } return returnValue; } }
,这里我们通过自己的逻辑判断拦截方法。
然后写测试代码:
public static void main(String[] args) { List<String> list=(List<String>) new DaoLogProxy().factory(new ArrayList<String>(),"includeMethods:add,get" ); list.add( "test0"); list.get(0); list.remove(0); }
非常方便,控制台显示如下信息表示成功:
2012-8-21 16:44:45 java.util.logging.LogManager$RootLogger log
信息: 执行class java.util.ArrayList的add方法,参数为test0
2012-8-21 16:44:45 java.util.logging.LogManager$RootLogger log
信息: 执行class java.util.ArrayList的get方法,参数为0
假如你是客户端程序员,你期望怎样的代理配置?
我的期望是:本框架为注入类提供一个注解,配置代理工厂,让容器读取注解信息,调用工厂代码生成代理类,然后注入,这样我的客户端接口调用
的任何方法都会被自己扩展的代理类拦截。
好吧,新建Proxy注解,
/** * 通过此注解 可以为任意类创建jdk代理 * @author duyf * */ @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE ) public @interface Proxy { /* * 必须指定自定义代理工厂 并且此工厂必须是ProxyFactory的子类 */ public Class proxyFactoryClass (); /* * 传递任意参数 让自定义代理工厂自行处理 */ public String params() default ""; }
注解的目标“客户”是类(Type)。proxyFactoryClass强制规定提供的代理工厂实现ProxyFactory接口,这里我们可以继承DefaultProxyFactory就ok了。
打开容器类BeanContainer,加上Proxy处理代码
Proxy proxy = iocObj.getClass().getAnnotation(Proxy .class); if (proxy != null ) { Object proxyFactoryClass = proxy.proxyFactoryClass().newInstance(); String params=proxy.params(); setObject = setProxyObject(proxyFactoryClass, setObject,params); } public Object setProxyObject(Object proxyFactoryClass, Object obj,Object params) { checkProxy(proxyFactoryClass); ProxyFactory pf = (ProxyFactory) proxyFactoryClass; return pf.factory(obj,params); } public void checkProxy(Object proxyFactoryClass) { if (!(proxyFactoryClass instanceof ProxyFactory)) { throw new RuntimeException( "所提供的代理类[" + proxyFactoryClass + "]必须实现ProxyFactory接口" ); } }
最后直接注入setObject到目标对象就行了。
测试一下:
1,创建一个测试接口UserService,UserServiceImpl实现接口,并用@Proxy注释
@Proxy(proxyFactoryClass=DaoLogProxy.class,params= "includeMethods:save,update" )
2,在action里面配置自动注入:
@Autowired(iocClass = UserServiceImpl.class) private UserService userService;
并给出setter方法。
3,配置Action,调用save方法,会打印出
执行class $Proxy9的save方法。
有了Proxy注解,以后任何人想扩展自己的代理将易如反掌
具体实现代码请参考源码。
By 阿飞哥 转载请说明
腾讯微博:http://t.qq.com/duyunfeiRoom
新浪微博:http://weibo.com/u/1766094735
原文地址:http://duyunfei.iteye.com/blog/1773721
发表评论
-
招Java培训老师(还是论坛招人靠谱)
2015-05-10 13:39 556好久没来坛子了,一来就搞这么有目的的事儿。。。 好吧, ... -
动手开发自己的mvc-2----完善控制层,提供自动注入和注解上传等功能
2013-01-22 13:44 2572当表单提交的内容过多 ,让懒惰的程序员一个个getPara ... -
动手开发自己的mvc-1----实现初步的控制层,实现各种配置和资源获取
2013-01-22 13:28 2807mvc框架最基础的功能就是跳转,struts2支持注 ... -
动手开发自己的mvc (系列)
2013-01-22 14:08 1928到年尾了,整理了一下我Evernote藏的各种文档,打算把ys ... -
整合了一个小的爬取流程框架
2013-01-08 13:04 1305弄了一个小的爬取流程框架,把之前工作中用到的一些小经验 ... -
Mahout各种推荐器的主要特点
2012-12-06 15:17 2980Mahout有很多推荐的实现,各有特点,在这里一并记录 ... -
怎样通过词频得到这个词频的排序?
2012-12-03 14:35 2070在大规模检索中,我们怎样通过已经的词频得到词频的排序 ... -
drools实现自定义业务规则
2012-10-12 11:49 2848最近做财务相关的积分规则,由于这个功能以后涉及到方方面面 ... -
贝叶斯文本分类 java实现
2012-09-25 15:15 12687昨天实现了一个基于贝叶斯定理的的文本分类,贝叶斯定理假 ... -
前段时间做了一个小型的MVC
2012-07-20 13:23 0前端时间做了一个小型的MVC,麻雀虽小,五脏俱全,目前实现的功 ... -
聚类算法之MST算法 java实现版本
2012-07-17 14:20 2804在介绍最小生成树算法(MST)之前,简单说一下平均链接算 ... -
聚类算法之单链接算法java实现
2012-07-05 10:09 4300聚类算法中基于链接的算法大致有三种:单链接算法(s ... -
朴素贝叶斯分类器
2012-05-20 15:25 0NaiveBayes分类器的优点是能得到已知Y的条件下X的 ... -
PageRank算法java实现版本
2012-05-16 16:03 17449PageRank算法是Google的核心搜索算法,在所有 ... -
聚类算法之kmeans算法java版本
2012-04-22 21:34 20886聚类的意思很明确,物以类聚,把类似的事物放在一起。 ... -
昨天做了个小工具DB转pojo,html,sql
2012-03-21 13:15 1765做dbutils时为了方便就做了个小工具,省点小事儿吧。 -
我这儿的讨论(项目小组)区可以进来了
2012-02-28 10:38 150java项目小组群,前几天清了几个破坏气氛者,和不发言 ... -
智能web探究群组建立了
2011-11-24 12:10 1613最近群组已申请成功 ,地址是http://web.gr ... -
Cas https方式改为http方式
2011-09-24 13:02 2339最近项目要测试,来不及申请等待证书,所以先把项目改为http的 ... -
jdk6原生态webservice
2011-06-30 13:38 8927近期做cas 单点登录的时候由于要同步用户信息,所以准备在 ...
相关推荐
【标题】"自己动手实现IOC和MVC源码"揭示了本文的核心内容,即通过实践来理解并构建IoC(Inversion of Control)和MVC(Model-View-Controller)这两种重要的软件设计模式的源代码。这两者是现代Java Web开发中...
《Java EE企业级应用开发教程(Spring+Spring MVC+MyBatis)》是一份全面深入讲解Java企业级应用开发的教程,重点聚焦于Spring、Spring MVC和MyBatis这三个核心框架。这些技术在现代Java开发中占据着举足轻重的地位...
本文将重点介绍Spring中的Web开发组件。 **假设**:本文假定读者已经具备一定的Java编程基础,并对MVC(Model-View-Controller)设计模式有一定的了解。此外,还假定读者对Spring框架的基本概念有所了解。 #### 二...
【标题】:“自己动手写框架”是一门针对初学者的实践教程,旨在引导学习者从零开始构建自己的软件开发框架。这个过程不仅涵盖了基础的编程原理,还涉及到设计模式、软件架构以及模块化等多个关键领域。 【描述】:...
《Spring+MVC+MYBatis企业应用实战》是一本深度探讨Java开发中三大核心框架集成应用的指南。Spring作为一款全面的企业级应用框架,提供了依赖注入、AOP(面向切面编程)以及众多模块,如Spring MVC和Spring JDBC,为...
【MyEclipse 6 Java 开发中文教程】 MyEclipse 6是一款强大的集成开发环境(IDE),专为Java开发者设计,特别适用于企业级应用的开发。这个教程详细介绍了如何使用MyEclipse 6进行Java开发,同时强调了SSH(Struts...
简历不仅是你向雇主展示自己专业能力和成就的窗口,也是你吸引面试官注意力的关键。以下是一个简洁而全面的简历模板,适用于那些寻求Java开发岗位或其他相关IT职位的求职者。 **基本信息** 姓名:[未提供] 求职...
《轻量级Java EE企业应用实战--Struts 2+Spring+Hibernate整合开发》这本书由李刚编著,主要探讨了在Java EE环境下如何利用轻量级框架进行高效的企业级应用开发。书中聚焦于三个核心的开源框架:Struts 2、Spring 和...
Servlet 3.1引入了许多新特性,例如异步处理、微容器(Microcontainer)支持和注解驱动的配置,这些都极大地简化了开发流程,提高了性能。 Tomcat 8.0是一个流行的开源JavaEE应用服务器,它实现了Servlet和JSP规范...
JavaWeb入门详细开发教程是一个针对初学者的综合指导材料,旨在帮助他们理解并掌握JavaWeb开发的基本概念和技术。本教程涵盖了从环境配置到项目构建的全过程,为学习者提供了全面的知识点。 首先,JavaWeb是基于...
在本教程中,我们将深入探讨Java Web程序设计的核心概念,主要针对"Java Web程序设计任务教程"的第一章内容。这是一份重要的学习资料,包含了教材的源码,可以帮助初学者和有经验的开发者更好地理解Java Web开发的...
根据提供的文件信息,我们可以将此课程的核心知识点概括并展开如下: ### 北风网 C++起步到MCF实战VC++软件工程师高端培训(服务器端开发方向)332课全 #### 一、课程概述 本课程是一套针对C++语言及MFC框架的全...
在本“JavaWeb视频教程_day22-资料源码”中,我们将深入探讨JavaWeb开发的核心概念和技术。JavaWeb是Java技术在Web开发领域的应用,它涵盖了从服务器端编程到客户端交互的诸多方面。本教程的重点可能是讲解如何利用...
SSM项目是Java web开发中常见的一种框架组合,由Spring、Spring MVC和MyBatis三个开源框架集成。这个实例教程是专为大学生设计的,旨在帮助他们从零开始理解和掌握SSM项目的实际应用。下面我们将深入探讨这个"大学生...
【描述】"java实战" 指出这个项目重点在于实际操作和应用Java编程语言,强调动手能力和解决实际问题的能力。在Java实战中,开发者通常会学习如何利用Java的特性和库来创建高效、稳定的软件系统。 【标签】"java实战...
《J2EE开发平台及程序设计》是一门针对软件工程、计算机科学与技术等领域专业的核心课程,旨在让学生理解和掌握Java企业级应用开发的关键技术。这门课程以32学时,2学分的形式展开,要求学生具备Java语言基础和Web...
本章将重点介绍Struts2的基础知识,它是SSH架构中的MVC(模型-视图-控制器)框架。 ### Struts2框架基础 Struts2是一个强大的、高度可定制的MVC框架,它旨在简化Java Web应用的开发。以下是Struts2的一些核心概念...
3. Web服务器:Tomcat 5.5及以上版本,配合MVC设计模式及 Hibernate开发架构; 4. 客户端运行环境:能运行IE 5以上或Netscape 5以上浏览器的操作系统,配合使用Ajax技术; 5. 客户端运行工具:目前的系统采用...
Spring框架是Java开发中不可或缺的一部分,它以其IoC(Inversion of Control)和AOP(Aspect-Oriented Programming)特性而闻名,极大地简化了企业级应用的开发工作。要深入理解Spring的工作原理,掌握其源码是至关...