Spring

反射与工厂模式实现Spring IOC

反射
包 java.lang.reflect
.java是我，.class是镜子里的我
反射是相对于正常方法调用更消耗性能的，当然会让方法更加灵活
不需要下方代码
if(“Apple”.equals(fruitName)){
f=new Apple();
}
这种定制的判断
对于反射，官方给出的概念：反射是Java语言的一个特性，它允许程序在运行时（注意不是编译的时候）来进行自我检查并且对内部的成员进行操作。例如它允许一个Java类获取它所有的成员变量和方法并且显示出来。

反射主要是指程序可以访问，检测和修改它本身状态或行为的一种能力，并能根据自身行为的状态和结果，调整或修改应用所描述行为的状态和相关的语义。在Java中，只要给定类的名字，那么就可以通过反射机制来获得类的所有信息。

反射是Java中一种强大的工具，能够使我们很方便的创建灵活的代码，这些代码可以在运行时装配，无需在组件之间进行源代码链接。但是反射使用不当会成本很高！类中有什么信息，利用反射机制就能可以获得什么信息，不过前提是得知道类的名字。

反射与工厂模式实现IOC简单概述
通过“名称”获取对象即反射，通过配置文件获取“名称”即IOC最基本实现。

反射与工厂模式实现IOC
Spring中的IoC的实现原理就是工厂模式加反射机制。 我们首先看一下不用反射机制时的工厂模式：

interface fruit{
public abstract void eat();
}
class Apple implements fruit{
public void eat(){
System.out.println(“Apple”);
}
}
class Orange implements fruit{
public void eat(){
System.out.println(“Orange”);
}
}
//构造工厂类
//也就是说以后如果我们在添加其他的实例的时候只需要修改工厂类就行了
class Factory{
public static fruit getInstance(String fruitName){
fruit f=null;
if(“Apple”.equals(fruitName)){
f=new Apple();
}
if(“Orange”.equals(fruitName)){
f=new Orange();
}
return f;
}
}
class hello{
public static void main(String[] a){
fruit f=Factory.getInstance(“Orange”);
f.eat();
}
}
复制ErrorOK!
上面写法的缺点是当我们再添加一个子类的时候，就需要修改工厂类了。如果我们添加太多的子类的时候，改动就会很多。下面用反射机制实现工厂模式：

interface fruit{
public abstract void eat();
}
class Apple implements fruit{
public void eat(){
System.out.println(“Apple”);
}
}
class Orange implements fruit{
public void eat(){
System.out.println(“Orange”);
}
}
class Factory{
public static fruit getInstance(String ClassName){
fruit f=null;
try{
f=(fruit)Class.forName(ClassName).newInstance();
}catch (Exception e) {
e.printStackTrace();
}
return f;
}
}
class hello{
public static void main(String[] a){
fruit f=Factory.getInstance(“Reflect.Apple”);
if(f!=null){
f.eat();
}
}
}
复制ErrorOK!
现在就算我们添加任意多个子类的时候，工厂类都不需要修改。使用反射机制实现的工厂模式可以通过反射取得接口的实例，但是需要传入完整的包和类名。而且用户也无法知道一个接口有多少个可以使用的子类，所以我们通过属性文件的形式配置所需要的子类。

下面编写使用反射机制并结合属性文件的工厂模式（即IoC）。首先创建一个fruit.properties的资源文件：

apple=Reflect.Apple
orange=Reflect.Orange
复制ErrorOK!
然后编写主类代码：

interface fruit{
public abstract void eat();
}
class Apple implements fruit{
public void eat(){
System.out.println(“Apple”);
}
}
class Orange implements fruit{
public void eat(){
System.out.println(“Orange”);
}
}
//操作属性文件类
class init{
public static Properties getPro() throws FileNotFoundException, IOException{
Properties pro=new Properties();
File f=new File(“fruit.properties”);
if(f.exists()){
pro.load(new FileInputStream(f));
}else{
pro.setProperty(“apple”, “Reflect.Apple”);
pro.setProperty(“orange”, “Reflect.Orange”);
pro.store(new FileOutputStream(f), “FRUIT CLASS”);
}
return pro;
}
}
class Factory{
public static fruit getInstance(String ClassName){
fruit f=null;
try{
f=(fruit)Class.forName(ClassName).newInstance();
}catch (Exception e) {
e.printStackTrace();
}
return f;
}
}
class hello{
public static void main(String[] a) throws FileNotFoundException, IOException{
Properties pro=init.getPro();
fruit f=Factory.getInstance(pro.getProperty(“apple”));
if(f!=null){
f.eat();
}
}
}

控制反转AOC、依赖注入DI的关系
依赖注入可以说是IOC的一个重点，在控制反转的过程中会通过扫描存放很多的bean，这时通过依赖注入将其需要的bean注入进去。@autowired和@resource就是依赖注入的实现。

@Autowired和@Resource区别
1.提供方不同

​ @Autowired 是Spring提供的，@Resource 是J2EE提供的。
2.装配时默认类型不同

​ @Autowired只按type装配,@Resource默认是按name装配。
3、使用区别
（1）@Autowired与@Resource都可以用来装配bean，都可以写在字段或setter方法上
（2）@Autowired默认按类型装配，默认情况下必须要求依赖对象存在，如果要允许null值，可以设置它的required属性为false。如果想使用名称装配可以结合@Qualifier注解进行使用。
（3）@Resource，默认按照名称进行装配，名称可以通过name属性进行指定，如果没有指定name属性，当注解写在字段上时，默认取字段名进行名称查找。如果注解写在setter方法上默认取属性名进行装配。当找不到与名称匹配的bean时才按照类型进行装配。但是需要注意的是，如果name属性一旦指定，就只会按照名称进行装配。

  BBfoitemMapper bfoItemMapper = ApplicationContextHolder.getBean("BBfoitemMapper");
  BfoMapper bfoMapper = ApplicationContextHolder.getBean("bfoMapper");
 获取beanName的时候其实是依照了jdk的驼峰命名规范，第一个字母大写的类 即 BfoMapper bfoMapper
                                                                                       第一个、二个字母大写的类 即 BBfoitemMapper
具体方法为：                                                                                       
public static String decapitalize(String name) {
    if (name == null || name.length() == 0) {
        return name;
    }
    if (name.length() > 1 && Character.isUpperCase(name.charAt(1)) &&
            Character.isUpperCase(name.charAt(0))){
        return name;
    }
    char chars[] = name.toCharArray();
    chars[0] = Character.toLowerCase(chars[0]);
    return new String(chars);
}
链接：https://blog.csdn.net/Fire_Cloud_1/article/details/131024305

处理循环依赖
处理方式一：

使用延迟加载：@Lazy的使用

@Resource
@Lazy
private IUserService userService;

处理方式二：已验证

把循环依赖断了。因为是加了岗位才引起，再这里把循环依赖断了。

去掉 岗位里面组织类的直接引用。

@Resource
private IOrgService orgService;

改成：使用的时候，再去获取bean的方式去获取

SpringUtils.getBean(OrgServiceImpl.class)