精华内容
下载资源
问答
  • Java中的依赖注入

    2020-08-16 18:11:12
    解析表面意思什么是依赖?可以简单地理解为import引入操作,比如import com.xxx.xxx;什么是注入?可以简单地理解为方法传参,就像给方法A(int temp)传入参数20;依赖注入可以理解为把原本要用import引入的资源,...
    • 解析表面意思:什么是依赖?可以简单地理解为import引入操作,比如import com.xxx.xxx;什么是注入?可以简单地理解为方法传参,就像给方法A(int temp)传入参数20;依赖注入可以理解为把原本要用import引入的资源,通过方法传参的形式引入,进而实现动态的决定要使用何种资源。这里也可以叫控制反转,就是把决定何种资源的控制权交由外部的使用者决定,也就是调用A(int temp)方法去决定。

    其实这里的依赖,不一定是import引入,也可以是对某个对象的引用,比如类A里会用到类B的实例,那么你可能会在类A里去构建一个类B的实例,而依赖注入就是把构建类B的操作通过一个API(容器)对外开发,让外部的使用者去做构建操作,它只要给传一个类B的实例给到类A就可以了。

    依赖注入的适用场景之一:当一个类依赖到一个或多个底层资源并且会受到资源影响的时候,使用依赖注入代替直接依赖。否则,当某个底层资源需要移除时,或者需要增加新的资源时,你就不得不修改这个类,这违背“开闭原则”。
    举一个例子:
    现在有个需求,需要将用户输入的英文内容转化为翻译的其他语言,假设已经引入或创建好多门语言的词典查询类,我可以起个翻译类:

    public class LanguageTranslateHelper {
    	private static final ChineseWords chineseWords;
    	private static final JapaneseWords japaneseWords;
    	...
    	private LanguageTranslateHelper() {}
    
    	public static String transToChinese(String enStr) {
    		chineseWords = new ChineseWords(...);
    		return chineseWords.trans(enStr);
    	}
    
    	public static String transToJapanese(String enStr) {
    		japaneseWords = new JapaneseWords(...);
    		return japaneseWords.trans(enStr);
    	}
    
    	...
    }
    

    使用依赖注入实现:
    实现一,假如底层语言库是通过第三方引入的:

    public class LanguageTranslateHelper {
    	private LanguageTranslateHelper() {}
    
    	public static String transToChinese(String enStr, @NotNull ChineseWords chineseWords) {
    		return chineseWords.trans(enStr);
    	}
    
    	public static String transToJapanese(String enStr, @NotNull JapaneseWords japaneseWords) {
    		return japaneseWords.trans(enStr);
    	}
    
    	...
    }
    

    实现二,假如底层语言库是自己实现的:

    //定义一个接口,ChineseWords JapaneseWords都实现了这个接口
    public interface ITranslate {
    	String translate(String enStr);
    }
    
    public class LanguageTranslateHelper {
    	private static final ITranslate words;
    	...
    	private LanguageTranslateHelper() {}
    
    	public static String transToChinese(String enStr, @NotNull ITranslate words) {
    		return words.trans(enStr);
    	}
    	...
    }
    
    展开全文
  • 什么是SQL注入呢? SQL注入意思是,用户输入了某些参数,最终导致SQL的执行偏离了程序设计者的本意,从而导致越权或者其他类型的错误。 也就是说因为用户输入的原因,导致SQL的涵义发送了变化。 拿我们最常用的...

    SQL注入
    什么是SQL注入呢?

    SQL注入的意思是,用户输入了某些参数,最终导致SQL的执行偏离了程序设计者的本意,从而导致越权或者其他类型的错误。

    也就是说因为用户输入的原因,导致SQL的涵义发送了变化。

    拿我们最常用的登录的SQL语句来说,我们可能会写下面的SQL语句:

    select * from user where username=’’ and password=’’
    我们需要用户传入username和password。

    怎么对这个SQL语句进行注入呢?

    很简单,当用户的username输入是下面的情况时:

    somebody’ or ‘1’='1
    那么整个SQL语句将会变成:

    select * from user where username=‘somebody’ or ‘1’=‘1’ and password=’’
    如果somebody是一个有效的用户,那么or后面的语言完全不会执行,最终导致不校验密码就返回了用户的信息。

    同样的,恶意攻击者可以给password输入下面的内容可以得到同样的结果:

    ’ or ‘1’='1
    整个SQL解析为:

    select * from user where username=‘somebody’ and password=’’ or ‘1’=‘1’
    这条语句将会返回所有的用户信息,这样即使不知道确定存在的用户名也可以通过SQL语句的判断。

    这就是SQL注入。

    java中的SQL注入
    java中最常用的就是通过JDBC来操作数据库,我们使用JDBC创建好连接之后,就可以执行SQL语句了。

    下面我们看一个java中使用JDBC SQL注入的例子。

    先创建一个通用的JDBC连接:

    public Connection getConnection() throws ClassNotFoundException, SQLException {
        Connection con = null;
            Class.forName("com.mysql.jdbc.Driver");
            System.out.println("数据库驱动加载成功");
            con = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/mysql?characterEncoding=UTF-8", "root", "");
            System.out.println("数据库连接成功");
          return con;
    }
    

    然后再自己拼装SQL语句然后调用:

    public void jdbcWithInjection(String username,char[] password) throws SQLException, ClassNotFoundException {
    Connection connection = getConnection();
    if (connection == null) {
    // Handle error
    }
    try {
    String pwd = encodePassword(password);

            String sqlString = "SELECT * FROM user WHERE username = '"
                    + username +
                    "' AND password = '" + pwd + "'";
            Statement stmt = connection.createStatement();
            ResultSet rs = stmt.executeQuery(sqlString);
    
            if (!rs.next()) {
                throw new SecurityException(
                        "User name or password incorrect"
                );
            }
        } finally {
            try {
                connection.close();
            } catch (SQLException x) {
            }
        }
    }
    

    上面的例子中,只有username会发生注入,password不会,因为我们使用了encodePassword方法对password进行了转换:

    public String encodePassword(char[] password){
    return Base64.getEncoder().encodeToString(new String(password).getBytes());
    }
    使用PreparedStatement
    为了防止SQL注入,我们一般推荐的是使用PreparedStatement,java.sql.PreparedStatement可对输入参数进行转义,从而防止SQL注入。

    注意,一定要正确的使用PreparedStatement,如果是不正确的使用,同样会造成SQL注入的结果。

    下面看一个不正确使用的例子:

    String sqlString = “SELECT * FROM user WHERE username = '”
    + username +
    “’ AND password = '” + pwd + “’”;
    PreparedStatement stmt = connection.prepareStatement(sqlString);
    ResultSet rs = stmt.executeQuery();
    上面的代码中,我们还是自己进行了SQL的拼装,虽然最后我们使用了preparedStatement,但是没有达到效果。

    正确使用的例子如下:

    String sqlString =
    “select * from user where username=? and password=?”;
    PreparedStatement stmt = connection.prepareStatement(sqlString);
    stmt.setString(1, username);
    stmt.setString(2, pwd);
    ResultSet rs = stmt.executeQuery();
    我们需要将用户输入作为参数set到PreparedStatement中去,这样才会进行转义。

    XML中的SQL注入
    可扩展标记语言(XML)旨在帮助存储,结构化和传输数据。 由于其平台独立性,灵活性和相对简单性,XML已在许多应用程序中得到使用。 但是,由于XML的多功能性,它容易受到包括XML注入在内的各种攻击的攻击。

    那么什么是XML注入呢?我们举个例子:

    Iphone20 5000.0 1 上面的例子中,我们使用了XML定义了一个iphone20的价格和数量。一个iphone20 5000块。

    上面的XML中,如果quantity是用户输入的数据的话,那么用户可以这样输入:

    120.01
    最后得出的XML文件如下:

    Iphone20 5000.0 1 20.01 一般来说,我们在解析XML的过程中,如果发现有重复的tag,那么后面的tag会覆盖前面的tag。

    结果就是1个iphone20现在的价格是20块,非常划算。

    XML注入的java代码
    我们看下XML的注入在java代码中是怎么实现的:

    public String createXMLInjection(String quantity){
        String xmlString = "<item>\n<name>Iphone20</name>\n"
                + "<price>5000.0</price>\n" + "<quantity>" + quantity
                + "</quantity></item>";
        return xmlString;
    }
    

    可以看到我们直接使用用户输入的quantity作为XML的拼接,这样做很明显是有问题的。

    怎么解决呢?有两种方法。

    第一种方法
    第一种方法就是对用户输入的quantity进行校验:

    public String createXML(String quantity){
        int count = Integer.parseUnsignedInt(quantity);
        String xmlString = "<item>\n<name>Iphone20</name>\n"
                + "<price>5000.0</price>\n" + "<quantity>" + count
                + "</quantity></item>";
        return xmlString;
    }
    

    上面代码中,我们对quantity进行了Integer的转换,从而避免了用户的非法输入。

    第二种方法
    第二种方法是使用XML Schema,来对生成的XML进行格式校验。

    先看一下我们改怎么定义这个XML Schema:

    <xs:schema xmlns:xs=“http://www.w3.org/2001/XMLSchema”>
    <xs:element name=“item”>
    xs:complexType
    xs:sequence
    <xs:element name=“name” type=“xs:string”/>
    <xs:element name=“price” type=“xs:decimal”/>
    <xs:element name=“quantity” type=“xs:nonNegativeInteger”/>
    </xs:sequence>
    </xs:complexType>
    </xs:element>
    </xs:schema>
    上面我们定义了一个XML element的序列sequence。如果用户输入了非定义格式的其他XML,就会报错。

    我们看下相对应的java代码该怎么写:

    StreamSource ss = new StreamSource(new File(“schema.xsd”));
    Schema schema = sf.newSchema(ss);
    SAXParserFactory spf = SAXParserFactory.newInstance();
    spf.setSchema(schema);
    SAXParser saxParser = spf.newSAXParser();
    XMLReader reader = saxParser.getXMLReader();
    reader.setContentHandler(defHandler);
    reader.parse(xmlStream);
    龙华大道1号 http://www.kinghill.cn/Dynamics/2106.html

    展开全文
  • 当某个角色(可能一个Java实例,调用者)需要另一个角色(另一个Java实例,被调用者)的协助时,在 传统的程序设计过程中,通常由调用者来创建被调用者的实例。但在Spring里,创建被调用者的工作不再由调用者来完成,...

    DI (Dependency Injection) 依赖注入

      依赖注入(Dependency Injection)是Spring框架的核心之一。
      当某个角色(可能是一个Java实例,调用者)需要另一个角色(另一个Java实例,被调用者)的协助时,在 传统的程序设计过程中,通常由调用者来创建被调用者的实例。但在Spring里,创建被调用者的工作不再由调用者来完成,因此称为控制反转;创建被调用者 实例的工作通常由Spring容器来完成,然后注入调用者,因此也称为依赖注入。
    详情

    OOP (Object Oriented Programming)面向对象编程

      面向对象编程技术的关键性观念是它将数据及对数据的操作行为放在一起,作为一个相互依存、不可分割的整体——对象。对于相同类型的对象进行分类、抽象后,得出共同的特征而形成了类。面向对象编程就是定义这些类。类是描述相同类型的对象集合。类定义好之后将作为数据类型用于创建类的对象。程序的执行表现为一组对象之间的交互通信。对象之间通过公共接口进行通信,从而完成系统功能。类中声明的public成员组成了对象的对外公共接口。 简单来说就是以功能为解决问题的中心。
    详情

    IoC (Inversion of Control) 控制反转

      控制反转(Inversion of Control,缩写为IoC),是面向对象编程中的一种设计原则,可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入(Dependency Injection,简称DI),还有一种方式叫“依赖查找”(Dependency Lookup)。通过控制反转,对象在被创建的时候,由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说,依赖被注入到对象中。
    详情

    展开全文
  • 在没用使用Spring的时候——也就是没有依赖注入的时候,java应用程序的类与类之间要实现相互的功能协作比较费劲的,某个类(A)要实现它的功能如果需要依赖另一个类(B)的协作的话,就需要在A类中主动创建出B类的...

    大家好,我是IT修真院西安分院第4期的JAVA学员,一枚正直纯洁善良的JAVA程序员。今天给大家分享一下,修真院官网Java任务1,深度思考中的知识点JDBC连接池原理
    一、.背景介绍
    在没用使用Spring的时候——也就是没有依赖注入的时候,java应用程序的类与类之间要实现相互的功能协作是比较费劲的,某个类(A)要实现它的功能如果需要依赖另一个类(B)的协作的话,就需要在A类中主动创建出B类的对象,才能使用B类的方法完成功能(这里看官就不要去纠结静态方法之类的情况了)。这等于是A类需要负责B类对象整个生命周期的管理。在极度简单的情况下,在一个类中new出另一个类的对象似乎并没有什么问题,但是复杂的应用程序类与类的协作关系往往是多边的,我们并不知道一个类功能的实现会依赖多少个另类对象来协作,所以在类中自行创建对象并且管理对象的整个生命周期,会造成代码的高度耦合以及不可想象的复杂度。那么,试想,如果我们能将对象的生命周期交给第三方组件来管理,当某个类需要另外的对象时第三方组件就直接创建出来交给它,这样,类就可以只专注于自己功能的实现,而不用去管理其他类对象的生命周期,这样类的功能就单纯了很多。是的,你一定已经明白了,Spring(容器)就是这个第三方组件。
    我们只需要告诉Spring(容器)有哪些对象需要管理就行了,不用去关心Spring框架是如何创建对象的。这样,当某个类A需要类B对象时,如果类B已经声明交给了Sping容器管理,那么在程序运行到类A需要类B时,Spring容器就通过依赖注入的方式,将类B对象注入到类A中协助完成业务功能。通过第三方组件的依赖注入,对象无需再自行的创建和管理类与类之间的依赖关系了。对象的创建依赖注入的方式也有多种,譬如接口注入,构造方法注入,setter方法注入等等。说到这里,你对依赖注入应该有比较直白的认知了。至于为什么要依赖注入,上文已经说得很明白了,就是为了减少代码中组件之间的耦合度,我们还是先通过简单示例来直观感受下依赖注入比自己管理对象的好处吧
    二、知识剖析
    IoC是什么

    Ioc—Inversion of Control,即“控制反转”,不是什么技术,而是一种设计思想。在Java开发中,Ioc意味着将你设计好的对象交给容器控制,而不是传统的在你的对象内部直接控制
    通过控制反转客户端不需要再主动创建对象,只需要通过IOC,由IOC去创建就可以了 由应用程序创建对象转变为由IOC容器来创建,用于控制创建对象的主体发生了改变,这是控制反转 应用程序需要的对象信息由IOC容器创建后注入,也就是说依赖于容器来注入,这是依赖注入 表达的是一个东西,只是描述的角度不同。 IOC,从容器的角度出发,容器反向控制应用程序对象的创建;
     
    DI(Dependency Injection),依赖注入;

    DI,从应用程序的角度出发,应用程序需要依赖容器注入对象;

    Spring是从哪里把对象给你的?

    Spring的容器为我们创建对象。容器的概念在java中你最熟悉的莫过于Tomcat了,它正是一个运行Servlet的web容器,而Spring要想实现依赖注入功能,就离不开对象生产的容器——如果没有容器负责对象的创建管理,你的程序代码只是喊要对象了,Spring也无处给你啊。实际上,容器是Spring框架实现功能的核心。

    实际上,容器里面什么都没有,决定容器里面放什么对象的是我们自己,决定对象之间的依赖关系的,也是我们自己,容器只是给我们提供一个管理对象的空间而已。

    我们怎么向容器中放入我们需要容器代为管理的对象呢?

    这就涉及到Spring的应用上下文了。什么是应用上下文呢,你可以简单的理解成就是将你需要Spring帮你管理的对象放入容器的那么一种。一种容器对象——是的,应用上下文即是Spring容器抽象的一种实现;而我们常见的ApplicationContext本质上说就是一个维护Bean定义以及对象之间协作关系的高级接口。

    听起来是不是很抽象拗口?那你再读一遍呢。。。这里,我们必须明确,Spring的核心是容器,而容器并不唯一,框架本身就提供了很多个容器的实现,大概分为两种类型:一种是不常用的BeanFactory,这是最简单的容器,只能提供基本的DI功能;还有一种就是继承了BeanFactory后派生而来的应用上下文,其抽象接口也就是我们上面提到的的ApplicationContext,它能提供更多企业级的服务,例如解析配置文本信息等等,这也是应用上下文实例对象最常见的应用场景。有了上下文对象,我们就能向容器注册需要Spring管理的对象了。
    spring中bean配置和bean注入
    Bean基本配置
    1 基于xml配置Bean
    对于基于XML的配置,Spring 2.0以后使用Schema的格式,使得不同类型的配置拥有了自己的命名空间,是配置文件更具扩展性
    2 使用注解定义Bean
    Spring容器成功启动的三大要件分别是:Bean定义信息、Bean实现类以及Spring本身。如果采用基于XML的配置,Bean定义信息和Bean实现类本身是分离的,而采用基于注解的配置方式时,Bean定义信息即通过在Bean实现类上标注注解实现。
    下面是使用注解定义一个DAO的Bean:ng本身。
    package com.baobaotao.anno; import org.springframework.stereotype.Component; import org.springframework.stereotype.Repository; //①通过Repository定义一个DAO的Bean @Component(“userDao”) public class UserDao { }。
    在①处,我们使用@Component注解在UserDao类声明处对类进行标注,它可以被Spring容器识别,Spring容器自动将POJO转换为容器管理的Bean。 它和以下的XML配置是等效的:
    3 基于java类提供Bean定义信息
    三、常见问题
    1 spring中的BeanFactory与ApplicationContext的作用和区别?
    2 什么是自动装配
    四、解决方案解决方案
    1 spring中的BeanFactory与ApplicationContext的作用和区别
    . BeanFactory负责读取bean配置文档,管理bean的加载,实例化,维护bean之间的依赖关系,负责bean的声明周期。 2. ApplicationContext除了提供上述BeanFactory所能提供的功能之外,还提供了更完整的框架功能: 比如资源访问,事件传递,通过ApplicationContext扩展了ResourceLoader(资源加载器)接口。 3. ApplicationContext的初始化和BeanFactory有一个重大的区别:BeanFactory在初始化容器时,并未实例化Bean,直到第一次访问某个Bean时才实例目标Bean;而ApplicationContext则在初始化应用上下文时就实例化所有的单实例的Bean。因此ApplicationContext的初始化时间会比BeanFactory稍长一些.
    .Spring容器能够自动装配相互合作的bean,这意味着容器不需要construor-arg和property配置,能通过Bean工厂自动处理bean之间的协作
    2 什么是自动装配
    .Spring容器能够自动装配相互合作的bean,这意味着容器不需要construor-arg和property配置,能通过Bean工厂自动处理bean之间的协作/p>
    五、编码实战

    public class Man implements Human { 
    	private QQCar car; public Man() { 
    	this.car = new QQCar(); } 
    	@Override public void xiabibi() { } 
    	public void driveCar(){ car.drive(); } }
    

    接口Car暂有两个实现:奔驰车和QQ车,在以上Man类和QQCar类高度耦合的代码中,老司机通过构造器只创建了QQ车对象,所以只能开QQ车,那么老司机想开奔驰怎么办呢,你让他重新创建奔驰车的对象吗?这样高度耦合的代码似乎是毫无办法的,那么,我们通过注入对象的方式对上述代码做一番改进:

    public class Man implements Human {
    	 private Car car; public Man(Car car) { this.car = car; }
    	  @Override public void xiabibi() { } public void driveCar() { car.drive(); }
    	   }
    

    以上代码根据多态特性,通过构造器接口注入的方式屏蔽掉了具体的对象实现,这样,老司机就能想开什么车就开什么车了。这就是依赖注入带来的好处。
    六、扩展思考
    6.1 Spring为我们提供了哪些类型的容器实现,供我们在什么样样的应用场景选择
    6.2 在xml文件中配置依赖注入都有哪几种方式
    七、参考文献
    https://www.cnblogs.com/chenbenbuyi/p/8166304.html
    https://www.cnblogs.com/wuchanming/p/5426746.html
    https://www.cnblogs.com/liwendeboke/p/6229564.html
    八、更多讨论
    1、 spring容器启动时做了什么?
    通过ApplicationContext context = new ClassPathXmlApplicationContext(“beans.xml”);这行代码的beans.xml来说吧。
    这个bean.xml文件里一般写的是这些内容
    bean标签定义了这个bean的唯一id,其实bean标签里也可以使用name=“someBean”,不过这样会导致如果有多个name名称相同,则前面定义的bean会被覆盖掉,所以一般为了防止这种情况出现,推荐使用id属性。
    spring容器在创建的时候会使用XmlBeanDefinitionReader这个类去解析这个xml文件,解析完成一个bean后把这个bean标签的信息放到一个叫BeanDefinition的对象里面。BeanDefinition是Spring IOC所识别的数据结构。有多少个bean标签,就有多少个BeanDefinition对象,最后把BeanDefinition对象放到Map里面。
    2、getBean(“someBean”)时做了什么?
    如果bean是单例,而且对象没有实例化,则按照上面写的流程利用反射new一个出来,然后放到Map里面。如果已经实例化,则直接从Map里面取出来直接返回。 如果是多例,每次都new一个返回。
    3、 IOC的优点是什么?
    IOC 或 依赖注入把应用的代码量降到最低。它使应用容易测试,单元测试不再需要单例和JNDI查找机制。最小的代价和最小的侵入性使松散耦合得以实现。IOC容器支持加载服务时的饿汉式初始化和懒加载。

    技能树.IT修真院“我们相信人人都可以成为一个工程师,现在开始,找个师兄,带你入门,掌控自己学习的节奏,学习的路上不再迷茫”。
    这里是技能树.IT修真院,成千上万的师兄在这里找到了自己的学习路线,学习透明化,成长可见化,师兄1对1免费指导。快来与我一起学习吧~我的邀请码:28769611,或者你可以直接点击此链接:http://www.jnshu.com/login/1/28769611

    视频链接
    PP链接

    展开全文
  • 大家好,我IT修真院郑州分院第12期学员,一枚正直纯洁善良的Java程序员。今天给大家分享一下,修真院官网JAVA(职业)任务1的知识点——Spring的IOC。 1.背景介绍 传统方式 对象和对象之间发生严重的依赖关系,...
  • 关于Ioc和DI在网上随便一搜都有很多,但是很多人的讲解呢,就是让人感觉深奥,看多了反而有些摸不清了,下面是我找到的一个利于理解的讲解可以看下 Ioc (控制反转) ...这是什么意思呢,举个简单...
  • spring 注入详解

    2017-08-12 15:27:50
    依赖注入是什么呢,这个一看名字就知道了,需要依赖别人才能实现自己的需求,而在spring中,我们可以设置很多Bean实例,在java中我们不用自己创建对象就能自己获取自己的实例,当然默认情况下都是单例模式。...
  • 什么意思呢?   当你年龄大了之后,工资自然duangduang往上长。但是你觉得你年龄往上长,你能力,技术真的往上长的吗?或者说跟年龄增长的速度比如何?   所以在完成日常的crud的工作之后,多想下如何提高工...
  • 安全架构-SQL注入原理及防范

    千次阅读 2020-12-17 19:09:17
    文章目录安全架构系列文章前言一、sql注入是什么?二、防范方法1.Java处理2 .NET处理总结 前言 一、sql注入是什么? SQL注入是通过客户端的输入把SQL命令注入到一个应用的数据库中,从而执行恶意的SQL语句。 * ...
  • java面试宝典

    2013-02-28 16:04:01
    47、在java 中一个类被声明为final 类型,表示了什么意思? 12 48、下面哪些类可以被继承? 12 49、指出下面程序的运行结果: 【基础】 13 52、关于内部类: 13 53、数据类型之间的转换: 14 54、字符串操作:如何实现...
  • 其实标题中如此高大上的名词,只是一个问题,关于在Spring的applicationContext.xml中的如下语句是什么意思? 这类语句在SSH的配置中会大量存在,因为Spring所谓的核心机制就是Spring依赖注入IOC。下面举一个例子...
  • Java常用注解

    2020-03-14 13:25:06
    目前4种注解意思是一样,并没有什么区别,区别只是名字不同。使用方法: @Controller publicclassTestController { } 2.@Autowired Autowired默认先按类型注入,如果发现找到多个bean,则又按照byN...
  • Spring是什么

    2020-12-30 14:23:09
    Spring一款免费的开源Web框架,它的核心IOC(控制反转)和DI(依赖注入),以及AOP(面向切面编程—应用于项目的性能监控,以及异常处理等等) Spring以灵活的特性,几乎可以兼容整合所有框架,它也完全展现了Java的...
  • CDI是什么?

    千次阅读 2015-05-28 11:27:01
    CDI(Contexts And Dependency Injection)JavaEE 6标准中一个规范,将依赖注入IOC/DI上升到容器级别, 它提供了Java EE平台上服务注入的组件管理核心,简化应该CDI的目标,让一切都可以被注解被注入。 Contexts...
  • java面试宝典2012

    2012-12-16 20:43:41
    18、Spring 的依赖注入是什么意思? 给一个 Bean 的 message 属性, 字符串类型, 注入值为 "Hello" 的 XML 配置文件该怎么写? 137 19、Jdo是什么? 137 20、什么是spring的IOC AOP 137 21、STRUTS的工作流程! 137 22、...
  • Java_框架面试题

    2019-04-04 15:14:42
    用DI注入时,Property代表什么意思,如果property引用的其他Bean的话,如何注入,如果引用字符串的话,如何设置? 使用DI注入时,Property代表注入类的属性,如果引用其他的bean,则用ref属性来表明被引用bean...
  • JAVA面试宝典2010

    2011-12-20 16:13:24
    18、Spring 的依赖注入是什么意思? 给一个 Bean 的 message 属性, 字符串类型, 注入值为 "Hello" 的 XML 配置文件该怎么写? 125 19、Jdo是什么? 125 20、什么是spring的IOC AOP 126 21、STRUTS的工作流程! 126 22、...
  • Java面试宝典-经典

    2015-03-28 21:44:36
    18、Spring 的依赖注入是什么意思? 给一个 Bean 的 message 属性, 字符串类型, 注入值为 "Hello" 的 XML 配置文件该怎么写? 125 19、Jdo是什么? 125 20、什么是spring的IOC AOP 126 21、STRUTS的工作流程! 126 22、...
  • 最新Java面试宝典pdf版

    热门讨论 2011-08-31 11:29:22
    18、Spring 的依赖注入是什么意思? 给一个 Bean 的 message 属性, 字符串类型, 注入值为 "Hello" 的 XML 配置文件该怎么写? 125 19、Jdo是什么? 125 20、什么是spring的IOC AOP 126 21、STRUTS的工作流程! 126 22、...
  • Java面试宝典2012版

    2012-12-03 21:57:42
    18、Spring 的依赖注入是什么意思? 给一个 Bean 的 message 属性, 字符串类型, 注入值为 "Hello" 的 XML 配置文件该怎么写? 125 19、Jdo是什么? 125 20、什么是spring的IOC AOP 126 21、STRUTS的工作流程! 126 ...
  • Java面试宝典2012新版

    2012-06-26 19:20:00
    18、Spring 的依赖注入是什么意思? 给一个 Bean 的 message 属性, 字符串类型, 注入值为 "Hello" 的 XML 配置文件该怎么写? 125 19、Jdo是什么? 125 20、什么是spring的IOC AOP 126 21、STRUTS的工作流程! 126 22、...
  • Java面试笔试资料大全

    热门讨论 2011-07-22 14:33:56
    18、Spring 的依赖注入是什么意思? 给一个 Bean 的 message 属性, 字符串类型, 注入值为 "Hello" 的 XML 配置文件该怎么写? 125 19、Jdo是什么? 125 20、什么是spring的IOC AOP 126 21、STRUTS的工作流程! 126 22、...
  • Java面试宝典2010版

    2011-06-27 09:48:27
    18、Spring 的依赖注入是什么意思? 给一个 Bean 的 message 属性, 字符串类型, 注入值为 "Hello" 的 XML 配置文件该怎么写? 19、Jdo是什么? 20、什么是spring的IOC AOP 21、STRUTS的工作流程! 22、spring 与EJB...
  • java学习之PreparedStatement

    千次阅读 热门讨论 2015-01-02 11:36:51
    Prepared看到这个单词,准备的意思,PreparedStatement实则预编译。那么与Statement又有什么区别呢?  PreparedStatemen有这样的好处:  1.防止重复编写多个结构类似的sql语句  2.没有拼接字符串的烦恼  3....
  • Java 面试宝典

    2013-02-01 10:02:08
    23、java 中实现多态的机制是什么? ......................................................................... 17 24、abstract class 和 interface 有什么区别? ...............................................
  • 一、控制反转(Ioc—Inversion of Control) 理解:IOC一种设计...谁控制谁,控制什么:在传统Java SE程序设计时,我们直接在对象内部通过new进行创建对象,程序主动去创建依赖对象;而IOC则专门有一个容器...
  • 18、Spring 的依赖注入是什么意思? 给一个 Bean 的 message 属性, 字符串类型, 注入值为 "Hello" 的 XML 配置文件该怎么写? 125 19、Jdo是什么? 125 20、什么是spring的IOC AOP 126 21、STRUTS的工作流程! 126 22、...
  • 3.Spring的依赖注入和控制反转分别代表什么意思,为什么要这么做?如果不控制反转会有什么不好的地方? 简单一句话,控制反转的好处的减低耦合度 推荐博客:www.cnblogs.com/hoobey/p/60… 4.因简历...

空空如也

空空如也

1 2 3 4
收藏数 63
精华内容 25
关键字:

java注入是什么意思

java 订阅