// 获取XML文件名获取应用上下文
ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");

// 根据bean的name属性获取到对象
User user = context.getBean("user", User.class);

// 调用对象方法
user.add();

// 创建类
public class Book{
    private String bname;
    private String bauthor;
    
    // 采用set方法进行属性注入
    public void setBname(String bname){
        this.bname=bname;
    }
    
    public void setBauthor(String bauthor){
        this.bauthor=bauthor;
    }
}

// 创建类
public class Orders{
    private String oname;
    private String address;
    
    // 有参数构造进行属性注入
    public Orders(String oname,String address){
        this.oname = oname;
        this.address = address;
    }
}

// 部门类，生成set方法方便注入
public class Dept {
    private String dname;

    public void setDname(String dname) {
        this.dname = dname;
    }
}

// 员工类
public class Emp {
    private String ename;
    private String gender;

    private Dept dept;

    public void setEname(String ename) {
        this.ename = ename;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public void setDept(Dept dept) {
        this.dept = dept;
    }
}

public class Stu {
    // 数据类型属性
    private String[] courses;

    // List类型属性
    private List<String> list;

    // Map类型属性
    private Map<String,String> maps;
    
    // Set类型属性
    private Set<String> sets;
	
    // 生成set方法
    public void setSets(Set<String> sets) {
        this.sets = sets;
    }

    public void setCourses(String[] courses) {
        this.courses = courses;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setMaps(Map<String, String> maps) {
        this.maps = maps;
    }

}

public class Stu {
    // 集合中对象类型注入
    private List<Course> courses;
	
    //set方法注入属性
    public void setCourses(List<Course> courses) {
        this.courses = courses;
    }
}

// 创建工厂类，实现接口FactoryBean
public class MyBean implements FactoryBean<User> {
    @Override
    public boolean isSingleton() {
        return false;
    }
	
    // 工厂可以获取到指定对象，这里获取的是User对象
    @Override
    public User getObject() throws Exception {
        User user = new User();
        user.setName("gy");
        return user;
    }

    @Override
    public Class<?> getObjectType() {
        return null;
    }
}

// 测试方法，根据applicationContext获取到的对象应该使用具体的类，这里使用的是User,所以根据注入的工厂bean获取到的的就是User对象
@Test
public void test1(){
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean1.xml");
    User myBean = applicationContext.getBean("myBean", User.class);
    System.out.println(myBean);

}

public class Order {
    private String oname;

    public Order(){
        System.out.println("第一步：通过无参构造创建bean实例");
    }

    public void setOname(String oname) {
        this.oname = oname;
        System.out.println("第二步：调用set方法设置属性");
    }

    public void initMethod(){
        System.out.println("第三步：执行初始化方法");
    }

    public void destory(){
        System.out.println("第四步：执行销毁方法");
    }
}

ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");

// 获取bean实例对象
Object myBean = context.getBean("myOrder");


// 手动让bean实例销毁，此方法只有ClassPathXmlApplicationContext有
context.close();

// 继承BeanPostProcessor的类可以重写方法
// 这两个方法可以在bean实例初始化前后被调用，可以对bean实例进行操作
public class MyBeanPost implements BeanPostProcessor {
    // 初始化前的操作
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return null;
    }
	
    // 初始化后的操作
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return null;
    }
}

@Configuration
@ComponentScan(basePackages={"com.company"})	//配置需要扫描的包名
public class SpringConfig{
    
}

ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class)
UserService userService = context.getBean("userService",UserService.class)

public class JDKProxy{
    public static void main(String[] args){
        Class[] interfaces = {UserDao.class};
       // 写法一：匿名内部类 
        /*
        Proxy.newProxyInstance(JDKProxy.class.getClassLoader(),interfaces,new InvocationHandler(){
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable{
                return null;
            }
        });
        */
        UserDaoImpl userDao = new UserDaoImpl();
        
        // 写法二：创建代理对象
        UserDao dao = (UserDao)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(),interfaces,new UserDaoProxy(userDao));
        dao.add(1,2);	// 相加的方法
        
    }
}


class UserDaoProxy implements InvocationHandler{
    // 写Onject是为了代码更通用
    private Object obj;
    
    // 获取到代理对象所代理的对象
    public UserDaoProxy(Object obj){
        this.obj = obj;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable{
        System.out.println("方法执行前..."+method.getName+
                           "\n传递的参数..."+Arrays.toString(args));
        
        // 执行增强方法
        Object res = method.invoke(obj,args);
        
        System.out.println("方法执行后...")
        return res;
    }
}

// execution([权限修饰符][返回类型][类全路径][方法名称]([参数列表]))
// 例1：对BookDao类里的add进行增强
execution(* com.company.dao.BookDao.add(...));

// 例2：对BookDao类里的所有方法进行增强
execution(* com.company.dao.BookDao.*(...));

// 例2：对包dao中所有类所有方法进行增强
execution(* com.company.dao.*.*(...));

@Component
@Aspect
public class UserProxy{
    // 前置通知
    @Before(value = "execution(* com.company.User.add([参数]))")
    public void before(){
        System.out.println("before......")
    }
    
    // 最终通知，方法之后执行
    @After(value = "execution(* com.company.User.add([参数]))")
    public void after(){
        System.out.println("after......")
    }
    
    // 后置通知，返回值之后执行，有异常时不执行
    @AfterReturning(value = "execution(* com.company.User.add([参数]))")
    public void afterReturning(){
        System.out.println("afterReturning......")
    }
    
    // 异常通知，有异常才执行
    @AfterThrowing(value = "execution(* com.company.User.add([参数]))")
    public void afterThrowing(){
        System.out.println("afterThrowing......")
    }
    
    // 环绕通知，此注解下的方法，在被增强方法执行之前和之后都执行
    @Around(value = "execution(* com.company.User.add([参数]))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
        System.out.println("around before......");
        
        // 被增强方法执行
        proceedingJoinPoint.proceed();
        
        System.out.println("around after......");
    }
    
}

@Pointcur(value = "execution(* com.company.User.add([参数]))")
public void pointdemo(){
    
}

@Component
@Aspect
public class UserProxy{
    // 前置通知，加入方法名称
    @Before(value = "pointdemo()")
    public void before(){
        System.out.println("before......")
    }
}

@Component
@Aspect
@Order(1)
public class PersonProxy{
    @Pointcur(value = "execution(* com.company.User.add([参数]))")
    public void pointdemo(){

    }
    
    // 前置通知，加入方法名称
    @Before(value = "pointdemo()")
    public void before(){
        System.out.println("before......")
    }
}

@Configuration
@ComponentScan(basePackages={"com.company"})	//配置需要扫描的包名
@EnableAspectJAutoProxy(proxyTargetClass=true)	// 默认为true，开启Aspect生成代理对象
public class AopConfig{
    
}

public class UserDaoImpl implements UserDao{
    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    @Override
    public void add(User user){
        String sql = "insert into user values(?,?,?)";
        
        Object[] args = {user.getUserId(),user.getUserName(),user.getPassword()}
        jdbcTemplate.update(sql,args);
    }
}

public class UserDaoImpl implements UserDao{
    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    @Override
    public void update(User user){
        String sql = "update user set user_name=?,password=? where user_id=?";
        
        Object[] args = {user.getUserName(),user.getPassword(),user.getUserId()}
        jdbcTemplate.update(sql,args);
    }
    
    @Override
    public void delete(String id){
        String sql = "delete from user where user_id=?";

        jdbcTemplate.update(sql,id);
    }
}

public class UserDaoImpl implements UserDao{
    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    // 查询用户数
    @Override
    public int selctCount(){
        String sql = "select count(*) from user";

        Integer count = jdbcTemplate.queryForObject(sql,Integer.class);
        
        return count;
    }
    
    // 根据id查询用户
    @Override
    public User findUserInfo(String id){
        String sql = "select * from user where user_id=?";
		// BeanPropertyRowMapper用于封装查询到的数据
        User user = jdbcTemplate.queryForObject(sql,new BeanPropertyRowMapper<User>(User.class),id);
        
        return user;
    }
    
    // 查询返回集合
    public List<User> findAll(){
        String sql = "select * from user";
        
        List<User> users = jdbcTemplate.query(sql,new BeanPropertyRowMapper<User>(User.class));
        
        return users;
    }
}

public class UserDaoImpl implements UserDao{
    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    // 批量添加,List<Object[]>中的Object[]表示参数的集合
    public int[] batchAdd(List<Object[]> barchArgs){
        String sql = "insert into user values(?,?,?)";
        
        // 返回的是影响的行数数组
        int[] res = jdbcTemplate.batchUpdate(sql,batchArgs);
        
        return res;
    }
    
    // 批量修改
    public int[] batchUpdate(List<Object[]> barchArgs){
        String sql = "update user set user_name=?,password=? where user_id=?";
        
        // 返回的是影响的行数数组
        int[] res = jdbcTemplate.batchUpdate(sql,batchArgs);
        
        return res;
    }
    
    // 批量删除
    public int[] batchDelete(List<Object[]> barchArgs){
        String sql = "delete from user where user_id=?";
        
        // 返回的是影响的行数数组
        int[] res = jdbcTemplate.batchUpdate(sql,batchArgs);
        
        return res;
    }
}

@Configuration
@ComponentScan(basePackages = "com.kuang")
@EnableTransactionManagement	// 开启事务
public class TxConfig{
    // 创建数据库连接池
	@Bean
    public DruidDataSource getDruidDataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://user_db");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        
        return dataSource;
    }
    
    //创建JdbcTemplate
    @Bean
    public JdbcTemplate getJdbcTemplate(DataSource dataSource){
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        jdbcTemplate.setDataSource(dataSource);
        
        return jdbcTemplate;
    }
    
    // 创建事务管理器
    @Bean
    public DataSourceTransactionManager getDataSourceTransactionManager(DataSource dataSource){
        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
        transactionManager.setDataSource(dataSource);
        return transactionManager;
    }
}

@SpringBootApplication
@EnableEurekaClient
public class PaymentHystrixMain8001 {
    public static void main(String[] args) {
        SpringApplication.run(PaymentHystrixMain8001.class,args);
    }
}

@Service
public class PaymentService {
    //正常访问，肯定不会报错
    public String paymentInfo_OK(Integer id){
        return "线程池： "+Thread.currentThread().getName()+"  paymentInfo_OK,id:  "+id+"\t"+"O(∩_∩)O哈哈~";
    }

    // 模拟超时
    public String paymentInfo_TimeOut(Integer id){
        int timeNumber=3;
        try{
            TimeUnit.SECONDS.sleep(timeNumber);	// 等待3秒
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        return "线程池： "+Thread.currentThread().getName()+"  paymentInfo_OK,id:  "+id+"\t"+"O(∩_∩)O哈哈~"+"   耗时"+timeNumber+"秒钟";
    }
}

@RestController
@Slf4j
public class PaymentController {
    @Resource
    private PaymentService paymentService;

    @Value("${server.port}")
    private String serverPort;

    @GetMapping("/payment/hystrix/ok/{id}")
    public String paymentInfo_OK(@PathVariable("id") Integer id){
        String result = paymentService.paymentInfo_OK(id);
        log.info("*********result:",result);
        return result;
    }

    @GetMapping("/payment/hystrix/timeout/{id}")
    public String paymentInfo_TimeOut(@PathVariable("id") Integer id){
        String result = paymentService.paymentInfo_OK(id);
        log.info("*********result:",result);
        return result;
    }
}

@SpringBootApplication
@EnableFeignClients
public class OrderHystrixMain8080 {
    public static void main(String[] args) {
        SpringApplication.run(OrderHystrixMain8080.class,args);
    }

}

@Service
@FeignClient(value = "CLOUD-PAYMENT-HYSTRIX-SERVICE")
public interface PaymentHystrixService {
    @GetMapping("/payment/hystrix/ok/{id}")
    public String paymentInfo_OK(@PathVariable("id") Integer id);

    @GetMapping("/payment/hystrix/timeout/{id}")
    public String paymentInfo_TimeOut(@PathVariable("id") Integer id);
}

@RestController
@Slf4j
public class OrderHystrixController {
    @Resource
    private PaymentHystrixService paymentHystrixService;

    @GetMapping("/consumer/payment/hystrix/ok/{id}")
    public String paymentInfo_OK(@PathVariable("id") Integer id){
        String result = paymentHystrixService.paymentInfo_OK(id);
        return result;
    }

    @GetMapping("/consumer/payment/hystrix/timeout/{id}")
    public String paymentInfo_TimeOut(@PathVariable("id") Integer id){
        String result = paymentHystrixService.paymentInfo_TimeOut(id);
        return result;
    }
}

@RestController
@Slf4j
public class OrderHystrixController {
    @GetMapping("/consumer/payment/hystrix/timeout/{id}")
    @HystrixCommand(fallbackMethod = "paymentInfo_TimeOutHandler",commandProperties={
        @HystrixProperty(name="execution.isolation.thread.timeoutInMilliseconds",value="3000")
    })
    public String paymentInfo_TimeOut(Integer id){
        int timeNumber=5;
        try{
            TimeUnit.SECONDS.sleep(timeNumber);	// 等待3秒
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        return "线程池： "+Thread.currentThread().getName()+"  paymentInfo_OK,id:  "+id+"\t"+"O(∩_∩)O哈哈~"+"   耗时"+timeNumber+"秒钟";
    }

    public String paymentInfo_TimeOutHandler(Integer id){
        return "接口调用异常：\t"+"当前线程名称\t"+Thread.currentThread().getName();
    }
}

@DefaultProperties(defaultFallback = "paymentInfo_TimeOutHandler")
public class OrderHystrixController{
    @GetMapping("/consumer/payment/hystrix/timeout/{id}")
    @HystrixCommand	// HystrixCommand还是要在需要降级的请求方法上加上
    public String paymentInfo_TimeOut(Integer id){
        int timeNumber=5;
        try{
            TimeUnit.SECONDS.sleep(timeNumber);	// 等待3秒
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        return "线程池： "+Thread.currentThread().getName()+"  paymentInfo_OK,id:  "+id+"\t"+"O(∩_∩)O哈哈~"+"   耗时"+timeNumber+"秒钟";
    }

    public String paymentInfo_TimeOutHandler(Integer id){
        return "接口调用异常：\t"+"当前线程名称\t"+Thread.currentThread().getName();
    }
}

@Component
public class PaymentFallbackService implements PaymentHystrixService{
    @Override
    public String paymentInfo_OK(Integer id){
        return "------PaymentHystrixService fall back-paymentInfo_OK";
    }
    
    @Override
    public String paymentInfo_TimeOut(Integer id){
        return "------PaymentHystrixService fall back-paymentInfo_TimeOut";
    }
}

@Service
@FeignClient(value = "CLOUD-PAYMENT-HYSTRIX-SERVICE" fallback = PaymentFallbackService.class)
public interface PaymentHystrixService {
    @GetMapping("/payment/hystrix/ok/{id}")
    public String paymentInfo_OK(@PathVariable("id") Integer id);

    @GetMapping("/payment/hystrix/timeout/{id}")
    public String paymentInfo_TimeOut(@PathVariable("id") Integer id);
}