java代码实现ioc JAVA代码实现九宫格输入,有英文数字两种模式

java代码中获得spring的IOC容器问题

1、获得spring配置文件

ClassPathResource cpr = new ClassPathResource("applicationContext.xml");

获取配置文件的第二种方法（通过文件系统获取配置文件，此时配置文件应该放在工程根目录下）：

ApplicationContext ctx = FileSystemXmlApplicationContext("applicationConetxt.xml");

2、把这个文件加载到工厂中

XmlBeanFactory factory = new XmlBeanFactory(cpr); 这样我们就可以在工厂中获取我们想要的东西，而不需要知道这个东西是怎么来的。

3、配置文件写法

bean id="chinese" class="类的全名"

4、通过XmlBeanFactory的getBean("beanId");

即：通过spring配置文件的bean标签的id，来得到相应的实例。

也即：factory.getBean(beanId);获得那个bean对象。

相关问答

Q1: 求大神，java中IOC具体是个什么意思

IOC（Inverse of Control）：控制反转。

1、本来程序使用哪一个bean是在程序中指定（由程序员具体指定）java代码实现ioc，而使用Spring以后java代码实现ioc我们将具体java代码实现ioc的配置写在xml中java代码实现ioc，由xml来控制；

2、本来类的实例化需要通过new XX() 来实例化一个对象，现在通过spring容器来帮忙实例化类的对象

Q2: java实现Spring的IOC机制

你说要把实现代码贴给你还是干吗啊？简单来讲，这个机制并不是很难的，将XML读入之后放到Map中，当你需要什么实例或者注入的时候，根据反射机制来生成。在XML里面都说明具体的实现类，com.test.test，这样就可以用反射机制生成test实例了，然后在赋给相关的变量即可。

当然，Spring的机制一定要比上面说的负责的多，包括依赖顺序的一大堆问题也需要解决

Q3: Java IOC 如何应用

二、 IOC使用的背景

在java代码实现ioc我们日常的设计中java代码实现ioc，类与类之间存在着千丝万缕的关系java代码实现ioc，如果两个类存在着强耦合关系java代码实现ioc，那么在维护时，一个类的修改很可能会牵动另一个类的关联修改，从而使得我们的维护工作步履维艰。下面让我们来看这样的一个强耦合反面例子。

首先我们建立一个Chinese.java类，该类的sayHelloWorld(String name)方法，用中文对名为name的人问好，其内容如下：

package org.amigo.reflection;

/**

*中国人类.

*@authora href="mailto:xiexingxing1121@126.com"AmigoXie/a

*Creationdate:2007-10-2-上午10:37:17

*/

publicclass Chinese {

/**

*用中文对某人问好.

*@paramname姓名

*/

publicvoid sayHelloWorld(String name) {

String helloWorld = "你好，" + name;

System.out.println(helloWorld);

}

}

下面我们接着建立一个American.java类，该类的sayHelloWorld(String name)方法，用英文对名为name的人问好，其内容如下：

package org.amigo.reflection;

/**

*美国人类.

*@authora href="mailto:xiexingxing1121@126.com"AmigoXie/a

*@version1.0

*Creationdate:2007-10-2-上午10:41:27

*/

publicclass American {

/**

*用英文对某人问好.

*@paramname姓名

*/

publicvoid sayHelloWorld(String name) {

String helloWorld = "Hello，" + name;

System.out.println(helloWorld);

}

}

最后我们编写一个测试类对这两个类的sayHelloWorld(String name)方法进行测试，下面是该类的内容：

package org.amigo.reflection;

/**

*HelloWorld测试.

*@authora href="mailto:xiexingxing1121@126.com"AmigoXie/a

*Creationdate:2007-10-2-上午10:45:13

*/

publicclass HelloWorldTest {

/**

*测试Chinese和American的sayHelloWorld()方法.

*@paramargs

*@authora href="mailto:xiexingxing1121@126.com"AmigoXie/a

*Creationdate:2007-10-2-上午10:43:51

*/

publicstaticvoid main(String[] args) {

Chinese chinese = new Chinese();

chinese.sayHelloWorld("阿蜜果");

American american = new American();

american.sayHelloWorld("Amigo");

}

}

观察HelloWorldTest我们可以很清楚的看到，该类与Chinese.java类和American.java类都存在强耦合关系。

上面的例子让我们想到的是在N年以前，当我们需要某个东西时，我们一般是自己制造。但是当发展到了一定的阶段后，工厂出现了，我们可以工厂中购买我们需要的东西，这极大的方便了我们。在上例中，我们都是通过new来创建新的对象，在开发中，这种强耦合关系是我们所不提倡的，那么我们应该如何来实现这个例子的解耦呢java代码实现ioc？我们接着想到了使用工厂模式，我们需要新建一个工厂类来完成对象的创建，并采用依赖接口的方式，此时需要对代码进行如下修改：

首先建立接口类Human.java，其内容如下。

package org.amigo.reflection;

/**

* 人类接口类.

* @author a href="mailto:xiexingxing1121@126.com"AmigoXie/a

* Creation date: 2007-10-2 - 上午11:04:56

*/

public interface Human {

/**

* 对某人问好.

* @param name 姓名

*/

public void sayHelloWorld(String name);

}

并将American.java类和Chinese.java类改为实现该接口，即类头分别改成：public class American implements Human和public class Chinese implements Human。

接着编写HumanFactory.java工厂类，其内容为：

package org.amigo.reflection;

/**

* 工厂类.

* @author a href="mailto:xiexingxing1121@126.com"AmigoXie/a

* Creation date: 2007-10-2 - 上午11:09:30

*/

public class HumanFactory {

/**

* 通过类型字段获取人的相应实例

* @param type 类型

* @return 返回相应实例

*/

public Human getHuman(String type) {

if ("chinese".equals(type)) {

return new Chinese();

} else {

return new American();

}

}

}

最后我们还需要修改测试类HelloWorld.java类，修改后的内容如下：

package org.amigo.reflection;

/**

* HelloWorld测试.

* @author a href="mailto:xiexingxing1121@126.com"AmigoXie/a

* Creation date: 2007-10-2 - 上午10:45:13

*/

public class HelloWorldTest {

/**

* 测试sayHelloWorld()方法.

* @param args

* @author a href="mailto:xiexingxing1121@126.com"AmigoXie/a

* Creation date: 2007-10-2 - 上午10:43:51

*/

public static void main(String[] args) {

HumanFactory factory = new HumanFactory();

Human human1 = factory.getHuman("chinese");

human1.sayHelloWorld("阿蜜果");

Human human2 = factory.getHuman("american");

human2.sayHelloWorld("Amigo");

}

}

观察此例我们可以看到，该类不再与具体的实现类Chinese和American存在耦合关系，而只是与它们的接口类Human存在耦合关系，具体对象的获取只是通过传入字符串来获取，很大程度上降低了类与类之间的耦合性。

Q4: java编程,spring里ioc和aop用什么原理实现的

控制反转（IOC）

（理解好Ioc的关键是要明确“谁控制谁，控制什么，为何是反转（有反转就应该有正转了），哪些方面反转了”）

1、Ioc—Inversion of Control：即“控制反转”，不是什么技术，而是一种设计思想。在Java开发中，Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。

2、谁控制谁，控制什么：传统Java SE程序设计，我们直接在对象内部通过new进行创建对象，是程序主动去创建依赖对象；而IoC是有专门一个容器来创建这些对象即由Ioc容器来控制对象的创建。

谁控制谁？当然是IoC 容器控制了对象。

控制什么？那就是主要控制了外部资源获取（不只是对象包括比如文件等）。

3、为何是反转，哪些方面反转了： 有反转就有正转，传统应用程序是由我们自己在对象中主动控制去直接获取依赖对象，也就是正转；而反转则是由容器来帮忙创建及注入依赖对象。

为何是反转？因为由容器帮我们查找及注入依赖对象，对象只是被动的接受依赖对象,所以是反转。

哪些方面反转了？依赖对象的获取被反转了。

还是不明白没事，下面搞个简单案例来说就懂啦 ！！！

例子：当我们在任何一个有实际开发意义的程序项目中，我们会使用很多类来描述他们特有的功能，并且通过类与类之间的相互协作来完成特定的业务逻辑。这个时候，每个类都需要负责管理与自己有交互的类的引用和依赖，代码将会变的异常难以维护和极高的高耦合。而IOC的出现正是用来解决这个问题，我们通过IOC将这些依赖对象的创建、协调工作交给spring容器去处理，每个对象值需要关注其自身的业务逻辑关系就可以了。在这样的角度上来看，获得依赖的对象的方式，进行了反转，变成了由spring容器控制对象如何获取外部资源（包括其他对象和文件资料等）。

总的来说：IOC就是通过在Xml配置文件里依赖注入来解决代码问题。

IOC的注入类型有几种？主要可以划分为三种：构造函数注入、属性注入和接口注入。Spring支持构造函数注入和属性注入

面向切面（AOP）

（面向切面编程，AOP其实只是OOP的补充而已，AOP基本上是通过代理机制实现的。）

我们管切入到指定类指定方法的代码片段称为切面，而切入到哪些类、哪些方法则叫切入点。有了AOP，我们就可以把几个类共有的代码，抽取到一个切片中，等到需要时再切入对象中去，从而改变其原有的行为。

我们都知道 Java 是 OOP-面向对象编程的，它有自己的优势，也有自己的不足。比如说：在我们开发中，都会有一条业务主线（即客户的需求）。而我们要做的就是实现这个主线上的需求。我们在实现这些功能的时候，经常要干一些额外的不可避免的事情，比如事务的管理，日志的记录等，就很繁杂且代码量增多，所以 Spring 提供了另一种角度来思考程序结构，也就是把这一些事情剥离出来，然后适时适地的把它们加入到我们的代码中，比如说 声明式事务管理的时候，我们在 service 层检测到save*、update*这些方法要被调用的时候，我们先进行开启事务什么的，这就是AOP，面向编程的思想。

AOP的术语：

1、通知（Advice）：就是你想要的功能，也就是上面说的 安全，事物，日志等。你给先定义好把，然后在想用的地方用一下

2、连接点（JoinPoint）：这个更好解释了，就是spring允许你使用通知的地方，那可真就多了，基本每个方法的前，后（两者都有也行），或抛出异常时都可以是连接点，spring只支持方法连接点.其他如aspectJ还可以让你在构造器或属性注入时都行，不过那不是咱关注的，只要记住，和方法有关的前前后后（抛出异常），都是连接点。

3、切入点（Pointcut）：上面说的连接点的基础上，来定义切入点，你的一个类里，有15个方法，那就有几十个连接点了对把，但是你并不想在所有方法附近都使用通知（使用叫织入，以后再说），你只想让其中的几个，在调用这几个方法之前，之后或者抛出异常时干点什么，那么就用切点来定义这几个方法，让切点来筛选连接点，选中那几个你想要的方法。

4、切面（Aspect）：切面是通知和切入点的结合。现在发现了吧，没连接点什么事情，连接点就是为了让你好理解切点，搞出来的，明白这个概念就行了。通知说明了干什么和什么时候干（什么时候通过方法名中的before,after，around等就能知道），而切入点说明了在哪干（指定到底是哪个方法），这就是一个完整的切面定义。

5、引入（introduction）：允许我们向现有的类添加新方法属性。这不就是把切面（也就是新方法属性：通知定义的）用到目标类中吗

6、目标（target）：引入中所提到的目标类，也就是要被通知的对象，也就是真正的业务逻辑，他可以在毫不知情的情况下，被咱们织入切面。而自己专注于业务本身的逻辑。

7、代理（proxy）：怎么实现整套aop机制的，都是通过代理，这个一会给细说。

8、织入（weaving）：把切面应用到目标对象来创建新的代理对象的过程。有3种方式，spring采用的是运行时，为什么是运行时，后面解释。

Q5: java中的Spring里面的ioc和aop有什么区别？他们都有什么用？

IOC的基本概念是：不创建对象，但是描述创建它们的方式。在代码中不直接与对象和服务连接，但在配置文件中描述哪一个组件需要哪一项服务。Spring容器负责将这些联系在一起。也就是说，Spring的IOC负责管理各种对象的创建、清除以及它们之间的联系。AOP是指面向切面编程（也叫面向方面），可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。一般用于事务管理、权限控制、错误处理等各种业务中共同性的东西。

java代码实现ioc的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于JAVA代码实现九宫格输入,有英文数字两种模式、java代码实现ioc的信息别忘了在本站进行查找喔。