精华内容
下载资源
问答
  • Java从入门到进阶+一站式学习Java框架技术
  • JAVA框架核心技术笔记

    2009-04-09 18:03:09
    JAVA框架核心技术笔记,JAVA框架核心技术笔记,JAVA框架核心技术笔记,JAVA框架核心技术笔记,JAVA框架核心技术笔记,JAVA框架核心技术笔记,JAVA框架核心技术笔记,JAVA框架核心技术笔记,JAVA框架核心技术笔记,JAVA框架...
  • java框架核心技术笔记

    2009-03-13 11:45:16
    java框架核心技术笔记,java框架核心技术笔记,java框架核心技术笔记
  • Java企业应用框架技术培训Java企业应用框架技术培训Java企业应用框架技术培训Java企业应用框架技术培训Java企业应用框架技术培训Java企业应用框架技术培训Java企业应用框架技术培训
  • Java反射技术详解

    万次阅读 多人点赞 2019-04-14 23:11:32
    相信很多人都知道反射可以说是Java中最强大的技术了,它可以做的事情太多太多,很多优秀的开源框架都是通过反射完成的,比如最初的很多注解框架,后来因为java反射影响性能,所以被运行时注解APT替代了,java反射有...

    前言

      相信很多人都知道反射可以说是Java中最强大的技术了,它可以做的事情太多太多,很多优秀的开源框架都是通过反射完成的,比如最初的很多注解框架,后来因为java反射影响性能,所以被运行时注解APT替代了,java反射有个开源框架jOOR相信很多人都用过,不过我们还是要学习反射的基础语法,这样才能自己写出优秀的框架,当然这里所讲的反射技术,是学习Android插件化技术、Hook技术等必不可少的!

    一、基本反射技术

          1.1 根据一个字符串得到一个类

            getClass方法

     String name = "Huanglinqing";
     Class c1 = name.getClass();
     System.out.println(c1.getName());
    

         打印结果如下:

        

        Class.forName

        比如我们获取java.lang.String的类名 

       String name = "java.lang.String";
       Class c1 = null;
       try {
              c1 = Class.forName(name);
              System.out.println(c1.getName());
          } catch (ClassNotFoundException e) {
      }
    

        这里也通过捕获异常,因为我们传的这个字符串可能不合法,字符串合法命名是类的命名空间和类的名称组成

        打印结果如下:

        
       我们还可以通过c1.getSuperclass()获取到他的父类

       Type属性

        基本类型都有type属性,可以得到这个基本类型的类型,比如:

    Class c1 = Boolean.TYPE;
    Class c2 = Byte.TYPE;
    Class c3 = Float.TYPE;
    Class c4 = Double.TYPE;
    
     停停停!这些东西有啥子用,如此鸡肋! 别急,一切都是为后续做准备。

    二、获取类的成员

             当类中方法定义为私有的时候我们能调用?不能!当变量是私有的时候我们能获取吗?不能!但是反射可以,比如源码中有你需要用到的方法,但是那个方法是私有的,这个时候你就可以通过反射去执行这个私有方法,并且获取私有变量。

           获取类的构造函数

           为了便于测试,我们定义一个Test类,Test类如下:(省略get和set方法)

           Test类中我们定义是三个私有变量,生成两个公有的含参构造方法和一个私有的含参构造方法以及一个公有的无参构造方法。

    public class Test {
    
        private int age;
        private String name;
        private int testint;
    
        public Test(int age) {
            this.age = age;
        }
    
        public Test(int age, String name) {
            this.age = age;
            this.name = name;
        }
    
        private Test(String name) {
            this.name = name;
        }
    
        public Test() {
        }
    

          下面我们通过反射获取这些构造方法

           获取类的所有构造方法

     Test test = new Test();
     Class c4 = test.getClass();
     Constructor[] constructors ;
     constructors = c4.getDeclaredConstructors();
    

          通过getDeclaredConstructors可以返回类的所有构造方法,返回的是一个数组因为构造方法可能不止一个,通过getModifiers可以得到构造方法的类型,getParameterTypes可以得到构造方法的所有参数,返回的是一个Class数组,所以我们如果想获取所有构造方法以及每个构造方法的参数类型,可以有如下代码:

      for (int i = 0; i < constructors.length; i++) {
            System.out.print(Modifier.toString(constructors[i].getModifiers()) + "参数:");
            Class[] parametertypes = constructors[i].getParameterTypes();
            for (int j = 0; j < parametertypes.length; j++) {
                 System.out.print(parametertypes[j].getName() + " ");
           }
          System.out.println("");
      }
    

        运行结果如下所示:

        

        这样我们就得到了类中所有构造方法和构造方法中的参数,那么我们如何获取特定的构造方法呢?

        获取类中特定的构造方法

        我们可以通过getConstructors方法获取类中 所有的public类型的构造方法,代码和上面一样就不演示了。

        我们可以通过getDeclaredConstructor()方法传参获取特定参数类型的构造方法,这里注意是getDeclaredConstructor()不是  getDeclaredConstructors() ,所以返回的是一个Class对象而不是一个Class数组。

        获取无参构造方法直接不传参数,如下所示:

       try {
              constructors = c4.getDeclaredConstructor();
              System.out.print(Modifier.toString(constructors.getModifiers()) + );
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
          }
    

        这里要进行异常捕获,因为可能不存在对应的构造方法,打印结果如下:  

        

       如果我们想获取有两个参数分别为int和String类型的构造方法,代码如下:

      Class[] p = {int.class,String.class};
      try {
           constructors = c4.getDeclaredConstructor(p);
           System.out.print(Modifier.toString(constructors.getModifiers()) + "参数:");
           Class[] parametertypes = constructors.getParameterTypes();
           for (int j = 0; j < parametertypes.length; j++) {
                System.out.print(parametertypes[j].getName() + " ");
              }
           } catch (NoSuchMethodException e) {
                e.printStackTrace();
         }
    

      这里我们同样打印出构造方法的参数:


      

      调用构造方法

       从这里开始慢慢到了关键的一步,得到类的实例,我们主要借助于newInstance方法,为了方便演示我们将测试类的两个构造方法打印出来. 

       public Test(int age, String name) {
            this.age = age;
            this.name = name;
            System.out.println("hello" + name + "i am" + age);
        }
    
    
        private Test(String name) {
            this.name = name;
            System.out.println("My Name is" +
                    name);
        }
    

       我们先来调用public的方法,如下所示:

     Class[] p = {int.class,String.class};
     constructors = c4.getDeclaredConstructor(p);
     constructors.newInstance(24,"HuangLinqing");
    

     运行打印结果如下:


      

     那么调用私有构造方法呢,和上面一样,只是我们要设置constructors.setAccessible(true);代码如下:

      Class[] p = {String.class};
      constructors = c4.getDeclaredConstructor(p);
      constructors.setAccessible(true);
      constructors.newInstance("HuangLinqing");
    

      打印结果如下:


       

    调用类的私有方法

      如何调用类中的私有方法呢,我们先在测试类中编写一个测试的私有方法 如下:

      private void welcome(String tips){
            System.out.println(tips);
        }
    

      我们知道如果我们要正常的调用类的方法都是通过类.方法调用,所以我们调用私有方法也需要得到类的实例,而我们上面newInstace已经得到了类的实例,这样就好办了。

       Class[] p4 = {String.class};
       Method method = c4.getDeclaredMethod("welcome",p4);
       method.setAccessible(true);
    

       我们首先通过 getDeclaredMethod方法获取到这个私有方法,第一个参数是方法名,第二个参数是参数类型

       然后通过invoke方法执行,invoke需要两个参数一个是类的实例,一个是方法参数。

         Class[] p4 = {String.class};
         Method method = c4.getDeclaredMethod("welcome",p4);
         method.setAccessible(true);
         Object arg1s[] = {"欢迎关注代码男人技术公众号"};
         method.invoke(test,arg1s);
    

         test类的实例当不能new 获取的时候我们也可以通过反射获取,就是上面的newInstance方法。打印结果如下:


        

     获取类的私有字段并修改值

      看到这里你可能会说,有了set方法,什么私有不私有,test.set不就可以了,但是这里要注意我们是没有办法得到这个类的实例的,要不然都可以得到实例就没有反射一说了。我们在通过反射得到类的实例之后先获取字段:

    Field field = c4.getDeclaredField("name");
    field.setAccessible(true);
    field.set(o,"代码男人");
    

       o是我们上面通过反射构造方法获取的实例,  打印field.get(o).toString()的值如下:
      

       

       不过要注意的是我们修改了name的值只对当前的实例对象有效。

       Java的基本反射语法就是这样了,欢迎加入技术群一起探讨!

      最后反射封装类如下:

    package jnidemo.hlq.com.hookdemo;
    
    import java.lang.reflect.Constructor;
    import java.lang.reflect.Field;
    import java.lang.reflect.Method;
    
    /**
     * @author Huanglinqing
     * @date 2019/4/28
     */
    
    public class Reflex {
    
        /**
         * 获取无参构造函数
         * @param className
         * @return
         */
        public static Object createObject(String className) {
            Class[] pareTyples = new Class[]{};
            Object[] pareVaules = new Object[]{};
    
            try {
                Class r = Class.forName(className);
                return createObject(r, pareTyples, pareVaules);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
    
            return null;
        }
    
        /**
         * 获取无参构造方法
         * @param clazz
         * @return
         */
        public static Object createObject(Class clazz) {
            Class[] pareTyple = new Class[]{};
            Object[] pareVaules = new Object[]{};
    
            return createObject(clazz, pareTyple, pareVaules);
        }
    
        /**
         * 获取一个参数的构造函数  已知className
         *
         * @param className
         * @param pareTyple
         * @param pareVaule
         * @return
         */
        public static Object createObject(String className, Class pareTyple, Object pareVaule) {
    
            Class[] pareTyples = new Class[]{pareTyple};
            Object[] pareVaules = new Object[]{pareVaule};
    
            try {
                Class r = Class.forName(className);
                return createObject(r, pareTyples, pareVaules);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
    
            return null;
        }
    
    
        /**
         * 获取单个参数的构造方法 已知类
         *
         * @param clazz
         * @param pareTyple
         * @param pareVaule
         * @return
         */
        public static Object createObject(Class clazz, Class pareTyple, Object pareVaule) {
            Class[] pareTyples = new Class[]{pareTyple};
            Object[] pareVaules = new Object[]{pareVaule};
    
            return createObject(clazz, pareTyples, pareVaules);
        }
    
        /**
         * 获取多个参数的构造方法 已知className
         * @param className
         * @param pareTyples
         * @param pareVaules
         * @return
         */
        public static Object createObject(String className, Class[] pareTyples, Object[] pareVaules) {
            try {
                Class r = Class.forName(className);
                return createObject(r, pareTyples, pareVaules);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
    
            return null;
        }
    
    
        /**
         * 获取构造方法
         *
         * @param clazz
         * @param pareTyples
         * @param pareVaules
         * @return
         */
        public static Object createObject(Class clazz, Class[] pareTyples, Object[] pareVaules) {
            try {
                Constructor ctor = clazz.getDeclaredConstructor(pareTyples);
                ctor.setAccessible(true);
                return ctor.newInstance(pareVaules);
            } catch (Exception e) {
                e.printStackTrace();
            }
    
            return null;
        }
    
    
        /**
         * 获取多个参数的方法
         * @param obj
         * @param methodName
         * @param pareTyples
         * @param pareVaules
         * @return
         */
        public static Object invokeInstanceMethod(Object obj, String methodName, Class[] pareTyples, Object[] pareVaules) {
            if (obj == null) {
                return null;
            }
    
            try {
                //调用一个private方法 //在指定类中获取指定的方法
                Method method = obj.getClass().getDeclaredMethod(methodName, pareTyples);
                method.setAccessible(true);
                return method.invoke(obj, pareVaules);
    
            } catch (Exception e) {
                e.printStackTrace();
            }
    
            return null;
        }
    
        /**
         * 获取一个参数的方法
         * @param obj
         * @param methodName
         * @param pareTyple
         * @param pareVaule
         * @return
         */
        public static Object invokeInstanceMethod(Object obj, String methodName, Class pareTyple, Object pareVaule) {
            Class[] pareTyples = {pareTyple};
            Object[] pareVaules = {pareVaule};
    
            return invokeInstanceMethod(obj, methodName, pareTyples, pareVaules);
        }
    
        /**
         * 获取无参方法
         * @param obj
         * @param methodName
         * @return
         */
        public static Object invokeInstanceMethod(Object obj, String methodName) {
            Class[] pareTyples = new Class[]{};
            Object[] pareVaules = new Object[]{};
    
            return invokeInstanceMethod(obj, methodName, pareTyples, pareVaules);
        }
    
    
        /**
         * 无参静态方法
         * @param className
         * @param method_name
         * @return
         */
        public static Object invokeStaticMethod(String className, String method_name) {
            Class[] pareTyples = new Class[]{};
            Object[] pareVaules = new Object[]{};
    
            return invokeStaticMethod(className, method_name, pareTyples, pareVaules);
        }
    
        /**
         * 获取一个参数的静态方法
         * @param className
         * @param method_name
         * @param pareTyple
         * @param pareVaule
         * @return
         */
        public static Object invokeStaticMethod(String className, String method_name, Class pareTyple, Object pareVaule) {
            Class[] pareTyples = new Class[]{pareTyple};
            Object[] pareVaules = new Object[]{pareVaule};
    
            return invokeStaticMethod(className, method_name, pareTyples, pareVaules);
        }
    
        /**
         * 获取多个参数的静态方法
         * @param className
         * @param method_name
         * @param pareTyples
         * @param pareVaules
         * @return
         */
        public static Object invokeStaticMethod(String className, String method_name, Class[] pareTyples, Object[] pareVaules) {
            try {
                Class obj_class = Class.forName(className);
                return invokeStaticMethod(obj_class, method_name, pareTyples, pareVaules);
            } catch (Exception e) {
                e.printStackTrace();
            }
    
            return null;
        }
    
        /**
         * 无参静态方法
         * @param method_name
         * @return
         */
        public static Object invokeStaticMethod(Class clazz, String method_name) {
            Class[] pareTyples = new Class[]{};
            Object[] pareVaules = new Object[]{};
    
            return invokeStaticMethod(clazz, method_name, pareTyples, pareVaules);
        }
    
        /**
         * 一个参数静态方法
         * @param clazz
         * @param method_name
         * @param classType
         * @param pareVaule
         * @return
         */
        public static Object invokeStaticMethod(Class clazz, String method_name, Class classType, Object pareVaule) {
            Class[] classTypes = new Class[]{classType};
            Object[] pareVaules = new Object[]{pareVaule};
    
            return invokeStaticMethod(clazz, method_name, classTypes, pareVaules);
        }
    
        /**
         * 多个参数的静态方法
         * @param clazz
         * @param method_name
         * @param pareTyples
         * @param pareVaules
         * @return
         */
        public static Object invokeStaticMethod(Class clazz, String method_name, Class[] pareTyples, Object[] pareVaules) {
            try {
                Method method = clazz.getDeclaredMethod(method_name, pareTyples);
                method.setAccessible(true);
                return method.invoke(null, pareVaules);
            } catch (Exception e) {
                e.printStackTrace();
            }
    
            return null;
        }
    
    
        public static Object getFieldObject(String className, Object obj, String filedName) {
            try {
                Class obj_class = Class.forName(className);
                return getFieldObject(obj_class, obj, filedName);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        public static Object getFieldObject(Class clazz, Object obj, String filedName) {
            try {
                Field field = clazz.getDeclaredField(filedName);
                field.setAccessible(true);
                return field.get(obj);
            } catch (Exception e) {
                e.printStackTrace();
            }
    
            return null;
        }
    
    
        public static void setFieldObject(Class clazz, Object obj, String filedName, Object filedVaule) {
            try {
                Field field = clazz.getDeclaredField(filedName);
                field.setAccessible(true);
                field.set(obj, filedVaule);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        public static void setFieldObject(String className, Object obj, String filedName, Object filedVaule) {
            try {
                Class obj_class = Class.forName(className);
                setFieldObject(obj_class, obj, filedName, filedVaule);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    
    
        public static Object getStaticFieldObject(String className, String filedName) {
            return getFieldObject(className, null, filedName);
        }
    
        public static Object getStaticFieldObject(Class clazz, String filedName) {
            return getFieldObject(clazz, null, filedName);
        }
    
        public static void setStaticFieldObject(String classname, String filedName, Object filedVaule) {
            setFieldObject(classname, null, filedName, filedVaule);
        }
    
        public static void setStaticFieldObject(Class clazz, String filedName, Object filedVaule) {
            setFieldObject(clazz, null, filedName, filedVaule);
        }
    }
    
     
    展开全文
  • 30种java技术框架

    热门讨论 2012-12-07 09:01:45
    30种java技术框架_方案架构图汇总.有很多以前使用的技术框架
  • 30种java技术框架

    2018-12-31 10:32:10
    30种java技术框架图汇总
  • 2014年java技术框架使用情况统计报告

    千次下载 热门讨论 2014-06-09 11:16:32
    2014年java相关技术与框架使用情况统计报告。英文。由RebelLabs统计。 JAVA TOOLS AND TECHNOLOGIES LANDSCAPE FOR 2014 A GLOBAL SURVEY OF ...包括不同java框架、服务器、构建工具,静态代码分析工具等的使用情况。
  • 什么是Java框架?主要的Java框架有哪些

    千次阅读 多人点赞 2020-01-17 22:18:35
    什么是Java框架?Java框架有哪些?Java框架可以简化开发难度,便于我们更好的开发程序。所以学好Java框架还是比较重要的。下面就简要描述一下Java开发常用的四大框架,以此来分析。 什么是Java框架 JAVA框架就是一些类...

    什么是Java框架?Java框架有哪些?Java框架可以简化开发难度,便于我们更好的开发程序。所以学好Java框架还是比较重要的。下面就简要描述一下Java开发常用的四大框架,以此来分析。
    什么是Java框架
    JAVA框架就是一些类和接口的集合,通过这些类和接口协调来完成一系列的程序实现。框架又叫做开发中的半成品,它不能提供整个WEB应用程序的所有东西,但是有了框架,我们就可以集中精力进行业务逻辑的开发而不用去关心它的技术实现以及一些辅助的业务逻辑。简单啊来说,就像我们盖房子如果我们没有房子整体的结构图我们只能一砖一砖的去磊房子,会磊成什么样子不说,一但磊歪了我们还得拆掉重新去磊。但是如果有人直接给我们搭建好了房子的整体结构呢?那就不一样了,我们只需要按照房子结构去往里面添砖就可以了。
    我这有个免费学习领取Java资料的裙768976403,欢迎各位同学加入一起讨论
    在这里插入图片描述
    加我q Q 315900256私聊也行,免费领取Java学习资料
    Java开发四大框架有哪些?
    Java的框架主要有:SpringMVC、Spring、Mybatis、Dubbo、Maven、RabbitMQ、Log4j、Ehcache、Redis、Shiro。以上十个Java框架并不需要都学会,只要会其中四五个比较常用的就可以了。
    第一个,SpringMVC。Spring MVC是一种基于Java的实现了Web MVC设计模式的请求驱动类型的轻量级Web框架,主要是帮助我们简化日常的Web开发。
    第二个,Mybatis。MyBatis 是支持普通 SQL查询,存储过程和高级映射的优秀持久层框架。
    第三个,Spring。Spring深得企业的青睐。
    第四个,Maven。越来越多的开发人员开始使用maven。

    展开全文
  • java核心技术精讲

    万人学习 2016-12-31 18:44:40
    本课程主要读者全面细致的讲解Java编程的所有核心知识,从基础语法、到面向对象以及Java的实际应用进行完整讲解。官方QQ群:612148723。
  • Java框架汇总

    千次阅读 2018-03-29 18:44:56
    Java框架

    Java框架

    Java总结

    Java编程

    Javaweb

    Java类库

    JavaEE

    集合框架

    展开全文
  • JAVA技术框架选型

    千次阅读 2015-06-16 20:41:50
    在做新项目的时候,遇到项目技术选型...3. 技术API文档是否完善,与其他框架的性能比较;   4. 是否开源,收费(如果需要进行开源改造)   5. 技术团队的技术氛围,新技术需要能尽量贴合团队成员的一贯开发路线;

             在做新项目的时候,遇到项目技术选型问题,思考了一下,可以从以下几个方面进行考虑:

    1.  技术应用场景

     

    2.  技术可靠性稳定性考虑,该技术是否得到了一定的应用

     

    3. 技术API文档是否完善,与其他框架的性能比较;

     

    4. 是否开源,收费(如果需要进行开源改造)

     

    5. 技术团队的技术氛围,新技术需要能尽量贴合团队成员的一贯开发路线;

     

     

    展开全文
  • public class ProducerAndConsumer { static BlockingQueue resourceQueue = new LinkedBlockingQueue<Resource>(10); public static void main(String[] args) { Producer p = new Producer();...
  • 如何才能学好java框架

    千次阅读 多人点赞 2018-01-11 18:21:30
    学习java已经三个月了,开始接触java框架的学习,就老师给我们讲解的框架知识,做了一下简单的总结,都是工作中能用到的实用的框架技术,还没整明白java框架的同胞们,快开启你的学习之旅吧!  刚开始学习Java...
  • [程序人生] 从选择 Java 框架谈谈技术人员的舒适区 # 作为技术人员, 积极的心态面对变化是必需的. 如果死死的守住一个小技术环境, 回报率自然会下降. 从软件业的发展来看, 也是这样. [流氓软件] Asynchronous ...
  • 常见JAVA框架

    万次阅读 2013-04-12 15:01:15
    Spring Framework 【Java开源JEE框架】 Spring是一个解决了许多在J2EE开发中常见的问题的强大框架。 Spring提供了管理业务对象的一致方法并且鼓励了注入对接口编程而不是对类编程的良好习惯。Spring的架构...
  • Java框架服务

    千次阅读 2017-07-01 15:49:37
    随着Java的流行,促生了许多java框架:Spring、WebWork、Struts、HIbernate、JDiy、JFinal、Quartz、Velocity、IBATIS、Compiere ERP&CRMSpring Framework【Java开源J2EE框架】 Spring是一个解决了许多在J2EE开发中...
  • Java系列技术之Spring5框架

    千人学习 2018-09-21 10:52:13
    Spring是一个开放源代码的设计层面框架,他解决的是业务逻辑层和其他各层的松耦合问题,因此它将面向接口的编程思想贯穿整个系统...本课讲全面的剖析Spring框架的核心技术,并带大家学会Spring在实际项目的使用方法!
  • Java系列技术之SpringMVC5框架

    千人学习 2018-09-21 11:06:40
    Spring MVC是当前最优秀的MVC框架,这门课程是基于Spring5.0.6的SpringMVC框架来讲解的,本套视频几乎涵盖 SpringMVC 开发过程中所有的技术问题,学习本套视频后,你会真正理解 SpringMVC 的优雅和简洁,并使你具备...
  • Java企业级框架技术-Topic 1 SSH框架

    千次阅读 热门讨论 2018-01-07 22:15:59
    框架技术解决的问题 使用框架技术能够解决以下三方面的问题。 实现常见任务,如数据转换、日志等。软件架构方案。 对特定领域问题的可重用、易扩展的解决方案。 什么是框架  框架(即Framework)是整个或部分...
  • java框架常见的面试题

    万次阅读 多人点赞 2019-03-19 17:53:34
    java框架常见的面试题spring什么是Spring?使用Spring框架的好处是什么?Spring由哪些模块组成?什么是Spring beans?解释Spring支持的几种bean的作用域Spring框架中的单例bean是线程安全的吗?解释Spring框架中bean的...
  • 轻量级 Java Web 框架技术选型

    千次阅读 2015-11-26 13:58:39
    前面已对该 Java Web 框架做了一些简要描述,目标就是打造一个轻量级的 Java Web 开发框架。我们不考虑使用 Struct、Spring、Hibernate 以及 MVC 模式,我们只是取其精华、去其糟粕,我们不是要重造轮子,而是要改造...
  • Java学习路线第三阶段:Java框架

    千次阅读 多人点赞 2018-09-25 11:21:17
    Java学习路线第三阶段:Java框架 框架是程序中另一种存储数据的方式,比直接使用数组来存储更加的灵活,在项目中应用十分广泛。同时,框架整合开发(SSH/SSS)、RESTful架构和移动端接口设计、第三方接口和在线支付...
  • java框架maven的demo

    2016-04-10 16:04:14
    框架搭建 maven+springmvc+mybatis 第一版:mavendemo 详细技术请见博客http://blog.csdn.net/zcjfzcjf
  • JAVA、WEB最新技术框架整理

    万次阅读 2017-01-10 09:43:34
    JAVA、WEB最技术框架整理1.基础框架1.1 后台基础框架 分布式:dubbox 统一配置:zookeeper 消息:kafka 服务化:spring spring boot 微服务化框架 spring mvc springframework 持久层:mybatis、hibernate、jedis ...
  • java框架概念

    千次阅读 2017-01-05 20:24:48
    Spring是一个解决了许多在J2EE开发中常见的问题的强大框架。  Spring提供了管理业务对象的一致方法并且鼓励了注入对接口编程而不是对类编程的良好习惯。 Spring的架构基础是基于使用JavaBean属性的Inversion of ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 553,168
精华内容 221,267
关键字:

java框架技术

java 订阅