java复制代码public class ClassA {
	private ClassB classB;

	public ClassB getClassB() {
		return classB;
	}

	public void setClassB(ClassB classB) {
		this.classB = classB;
	}
}
public class ClassB {
	private ClassA classA;

	public ClassA getClassA() {
		return classA;
	}

	public void setClassA(ClassA classA) {
		this.classA = classA;
	}
}

xml复制代码<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

	<bean id="classA" class="ioc.cd.ClassA">
		<property name="classB" ref="classB"></property>
	</bean>
	<bean id="classB" class="ioc.cd.ClassB">
		<property name="classA" ref="classA"></property>
	</bean>
</beans>

java复制代码	@Test
	public void test() throws Exception {
		// 创建IoC容器，并进行初始化
		String resource = "spring/spring-ioc-circular-dependency.xml";
		ApplicationContext context = new ClassPathXmlApplicationContext(resource);
		// 获取ClassA的实例（此时会发生循环依赖）
		ClassA classA = (ClassA) context.getBean(ClassA.class);
	}

shell复制代码# 查看有哪些数据库
show dbs

# 创建或进入数据库 （当数据库不存在即创建）
use dbName

# 查看有哪些集合
show collections

shell复制代码# 可以直接向集合插入数据，对不存在的集合将会创建
db.collName.insert({"name":"Axton", "age":20})

shell复制代码# 显示集合中全部文档
db.collName.find()

# 显示集合中特定文档
db.collName.find({ "name":"Axton" })

# 排序，按 ID 倒序排序
db.collName.find().sort({_id:-1})

shell复制代码db.collName.update({"name":"Axton", $set:{"name": "Axton2"}})

shell复制代码db.collName.remove({"name": "Axton"})

shell复制代码# 初始化 node.js 环境
npm init -y

# 安装 mongodb 模块
npm i mongodb --save

js复制代码const MongoClient = require('mongodb').MongoClient

const url = 'mongodb://localhost:27017'		// 默认端口号为 27017 ，如修改过请自行更改
const dbName = 'mydb'		// 需要连接的数据库名字

MongoClient.connect(
  url,
  {
    // 配置 （默认写上就好）
    useUnifiedTopology: true
  },
  (err, client) => {
    if (err) {
      console.error('mongodn connect error', err)
      return
    }

    console.log('mongodb connect success')

    // 切换到数据库
    const db = client.db(dbName)

    // 关闭连接
    client.close()
  }
)

js复制代码const MongoClient = require('mongodb').MongoClient

const url = 'mongodb://localhost:27017'
const dbName = 'mydb'

MongoClient.connect(
  url, 
  {
    useUnifiedTopology: true
  },
  (err, client) => {
    if (err) {
      console.error('mongodn connect error', err)
      return
    }
    console.log('mongodb connect success')
    const db = client.db(dbName)

    // 使用集合
    const usersCollection = db.collection('students')

    // ------- 文档的操作代码写在此部分，之后将不再包含连接部分代码 -------
    // 查询文档
    usersCollection.find({	// find() 内不写内容则为查询全部文档
        "name" : "Axton"
    }).toArray((err, res) => {
      if (err) {
        console.error(err)
        return
      }
      console.log(res)

      // find() 为异步操作，为了使查询完后在关闭数据，所以放至此位置
      client.close()
    })
    // -------------------------------------------------------------
  }
)

js复制代码// 插入一条数据， 插入多条可以选择 insertMany()
usersCollection.insertOne({
  name: 'Jack',
  sex: '男',
  age: 21
}, (err, res) => {
  if (err) {
    console.error(err)
    return
  }
  console.log(res)
  client.close()
})

js复制代码// 更新一条数据， 更新多条可以选择 updateMany()
usersCollection.updateOne(
  {name: 'Jack'},   // 查询条件
  {$set: {info: '女装'}},   // 更新的内容
   (err, res) => {
     if (err) {
       console.error(err)
       return
     }
     console.log(res)
     client.close()
  }
)

js复制代码// 删除一条数据， 删除多条可以选择 deleteMany()
usersCollection.deleteOne({
    name: 'Jack'
}, (err, res) => {
    if (err) {
        console.error(err)
        return
    }
    console.log(res)
    client.close()
})

shell复制代码npm i mongoose --save

go复制代码mongoose-test
├── package-lock.json
├── package.json
├── node_modules
└── src
    ├── db.js
    ├── models
    │	  └── Student.js
    └── test
   	  └── student.js

js复制代码const mongoose = require('mongoose')

const url = 'mongodb://localhost:27017'
const dbName = 'myblog'

mongoose.connect(`${url}/${dbName}`, {
  useUnifiedTopology: true,
  useNewUrlParser: true
})

const db = mongoose.connection    // 将连接对象赋给 db

// 发送错误
db.on('error', err => {
  console.error(err)
})

// 连接成功
db.on('open', () => {
  console.log('success!')
})

module.exports = mongoose

js复制代码// 对应 students 集合

const mongoose = require('../db')

// 用 Schema 定义数据规范
const StudentSchema = mongoose.Schema({
  name: {
    type: String,
    required: true,
    unique: true
  },
  sex: String,
  age: Number
}, {
  timestamps: true  // 时间戳， 在插入、更新数据后将会加上相应的时间数据
  // 在每一条文档中加入 createdAt 和 updatedAt
})

// Model 对于 Collection
const Student = mongoose.model('student', StudentSchema)

module.exports = Student

js复制代码const Student = require('../models/Student')

// 自执行的异步函数
!(async () => {
    
  // 查询文档
  const res = await Student.find({
    name: 'Axton'
  })

  // 用正则表达式模糊查询文档
  const res2 = await Student.find({
    name: /A/
  })
  
  // 根据 ID 查询单条文档
  const res3 = await Student.findById('5fb2247e6469170600f02551')

})()

js复制代码const Student = require('../models/Student')

!(async () => {
    
  // 插入文档
  const res = await Student.create({
    name: 'Jack',
    age: 21,
    sex: '男'
  })

})()

js复制代码const Student = require('../models/Student')

!(async () => {

  // 更新文档
  const res = await Student.findOneAndUpdate(
    {name: 'Jack'},   // 查询的条件
    {sex: '女'},
    {
      new: true  // 返回修改之后的内容，默认为 fasle
    }
  )

})()

js复制代码const Student = require('../models/Student')

!(async () => {

  // 删除文档
  const res = await Student.findOneAndDelete({
    name: 'Jack'
  })

})()

csharp复制代码 class UserViewInfo
    {
        //用户ID
        public int UserId { get; set; }
        //访问时间，utc时间戳
        public int Time { get; set; }
        //用户姓名
        public string UserName { get; set; }
    }

csharp复制代码class UserSpace
    {
        //缓存的最大数量
        const int CacheLimit = 1000;
        //这里用双向链表来缓存用户空间的访问记录
        LinkedList<UserViewInfo> cacheUserViewInfo = new LinkedList<UserViewInfo>();
        //这里用哈希表的变种Dictionary来存储访问记录，实现快速访问，同时设置容量大于缓存的数量限制，减小哈希冲突
        Dictionary<int, UserViewInfo> dicUserView = new Dictionary<int, UserViewInfo>(1250);

        //添加用户的访问记录
        public void AddUserView(UserViewInfo uv)
        {
            //首先查找缓存列表中是否存在，利用hashtable来实现快速查找
            if (dicUserView.TryGetValue(uv.UserId, out UserViewInfo currentUserView))
            {
                //如果存在，则把该用户访问记录从缓存当前位置移除，添加到头位置
                cacheUserViewInfo.Remove(currentUserView);
                cacheUserViewInfo.AddFirst(currentUserView);
            }
            else
            {
                //如果不存在，则添加到缓存头部 并添加到哈希表中
                cacheUserViewInfo.AddFirst(uv);
                dicUserView.Add(uv.UserId, uv);
            }
            //这里每次都判断一下缓存是否超过限制
            if (cacheUserViewInfo.Count > CacheLimit)
            {
                //移除缓存最后一个元素，并从hashtable中删除,理论上来说，dictionary的内部会两个指针指向首元素和尾元素，所以查找这两个元素的时间复杂度为O（1）
                var lastItem = cacheUserViewInfo.Last.Value;
                dicUserView.Remove(lastItem.UserId);
                cacheUserViewInfo.RemoveLast();
            }
        }
    }

arduino复制代码public enum MsgType {

    CHAT_MSG,
    SYS_MSG;
}

less复制代码@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface Type {
    MsgType value();
}

arduino复制代码public interface BaseMsgHandler {
    void handleMsg(String content);
}

less复制代码@Component
@Type(value = MsgType.CHAT_MSG)
public class ChatMsgHandler implements BaseMsgHandler{

    @Override
    public void handleMsg(String msg) {
        System.out.println("This is chatMsg. Detail msg information is :" + msg);
    }
}

less复制代码@Component
@Type(value = MsgType.SYS_MSG)
public class SysMsgHandler implements BaseMsgHandler{

    @Override
    public void handleMsg(String msg) {
        System.out.println("This is sysMsg. Detail msg information is :" + msg);
    }
}

swift复制代码public static final Map<Type, BaseMsgHandler> msgStrategyMap = new HashMap<>();

scss复制代码@Component
public class MsgConfig implements ApplicationContextAware {

    public static final Map<Type, BaseMsgHandler> msgStrategyMap = new HashMap<>();

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        applicationContext.getBeansWithAnnotation(Type.class).entrySet().iterator().forEachRemaining(entrySet ->{
            msgStrategyMap.put(entrySet.getKey().getClass().getAnnotation(Type.class),
                    (BaseMsgHandler) entrySet.getValue());
        });
    }
}

kotlin复制代码import lombok.Data;

@Data
public class Msg{
	private String content;
	private MsgType msgType;
}

less复制代码@RestController
@RequestMapping("/")
public class MsgController {

    @RequestMapping("msg")
    public void handleMsg(@RequestBody Msg msg){
        BaseMsgHandler handler = MsgConfig.msgStrategyMap.get(msg.getMsgType());
        handler.handleMsg(msg.getContent());
    }
}

mysql复制代码#getOrderNo是用户自定义一个函数用户来根据order_sn来获取订单编号
select id, payment_id, order_sn, getOrderNo(order_sn) from payment_transaction where status = 1 and create_time between '2020-10-01 10:00:00' and '2020-10-02 10:00:00';

mysql复制代码#表request_log的中content是text类型。
select user_id, content, status, url, type from request_log where user_id = 32121;

mysql复制代码select batch_id, group_concat(name) from buffer_batch where status = 0 and create_time between '2020-10-01 10:00:00' and '2020-10-02 10:00:00';

mysql复制代码select id,(select rule_name from member_rule limit 1) as rule_name, member_id, member_type, member_name, status  from member_info m where status = 1 and create_time between '2020-09-02 10:00:00' and '2020-10-01 10:00:00';

mysql复制代码SELECT a.member_id,a.create_time,b.active_time FROM operation_log a LEFT JOIN member_info b ON a.member_id = b.member_id where  b.`status` = 1
and a.create_time between '2020-10-01 00:00:00' and '2020-10-30 00:00:00' limit 100, 0;

mysql复制代码select b.member_id,b.member_type, a.create_time,a.device_model from member_operation_log a inner join (select member_id,member_type from member_base_info where `status` = 1
and create_time between '2020-10-01 00:00:00' and '2020-10-30 00:00:00') as b on a.member_id = b.member_id;

mysql复制代码#device_no列上有索引，由于使用了ltrim函数导致索引失效
select id, name , phone, address, device_no from users where ltrim(device_no) = 'Hfs1212121';
#balance列有索引,由于做了运算导致索引失效
select account_no, balance from accounts where balance + 100 = 10000 and status = 1;

mysql复制代码#user_id是bigint类型，传入varchar值发生了隐式类型转换，可以走索引。
select id, name , phone, address, device_no from users where user_id = '23126';
#card_no是varchar(20)，传入int值是无法走索引
select id, name , phone, address, device_no from users where card_no = 2312612121;

mysql复制代码character_set_server  =  utf8mb4    #数据库实例字符集
character_set_connection = utf8mb4  #连接字符集
character_set_database = utf8mb4    #数据库字符集
character_set_results = utf8mb4     #结果集字符集

mysql复制代码#device_no字段类型varchar(200)，创建了前缀索引。
mysql> alter table users add index idx_device_no(device_no(64));

mysql> select device_no, count(*) from users where create_time between '2020-10-01 00:00:00' and '2020-10-30 00:00:00' group by device_no;

mysql复制代码select DATE_FORMAT(create_time, '%Y-%m-%d'), count(*) from users where create_time between '2020-09-01 00:00:00' and '2020-09-30 23:59:59' group by DATE_FORMAT(create_time, '%Y-%m-%d');

mysql复制代码#新插入的id值会从10001开始，这是不对的，应该从1开始。
create table booking( `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键id',......) engine = InnoDB auto_increment = 10000;

#指定了id值插入，后续自增就会从该值开始+1，索引禁止指定id值插入。
insert into booking(id, book_sn) values(1234551121, 'N12121');

mysql复制代码mysql> select count(*) from member_info;
+----------+
| count(*) |
+----------+
|   148416 |
+----------+
1 row in set (0.35 sec)

mysql> show index from member_base_info;
+------------------+------------+----------------------------+--------------+-------------------+-----------+-------------+----------+--------+------+------------+---------+---------------+
| Table            | Non_unique | Key_name                   | Seq_in_index | Column_name       | Collation | Cardinality | Sub_part | Packed | Null | Index_type | Comment | Index_comment |
+------------------+------------+----------------------------+--------------+-------------------+-----------+-------------+----------+--------+------+------------+---------+---------------+
| member_info |          0 | PRIMARY                    |            1 | id                | A         |      131088 | NULL     | NULL   |      | BTREE      |         |               |
| member_info |          0 | uk_member_id               |            1 | member_id         | A         |      131824 | NULL     | NULL   |      | BTREE      |         |               |
| member_info |          1 | idx_create_time            |            1 | create_time       | A         |        6770 | NULL     | NULL   |      | BTREE      |         |               |
+------------------+------------+----------------------------+--------------+-------------------+-----------+-------------+----------+--------+------+------------+---------+---------------+
#Table： 表名
#Non_unique ：是否为unique index，0-是，1-否。
#Key_name：索引名称
#Seq_in_index：索引中的顺序号，单列索引-都是1；复合索引-根据索引列的顺序从1开始递增。
#Column_name：索引的列名
#Collation：排序顺序，如果没有指定asc/desc，默认都是升序ASC。
#Cardinality：索引基数-索引列唯一值的个数。
#sub_part：前缀索引的长度；例如index (member_name(10)，长度就是10。
#Packed：索引的组织方式，默认是NULL。
#Null：YES:索引列包含Null值；'':索引不包含Null值。
#Index_type：默认是BTREE，其他的值FULLTEXT，HASH，RTREE。
#Comment：在索引列中没有被描述的信息，例如索引被禁用。
#Index_comment：创建索引时的备注。

mysql复制代码alter table member_info add index idx_member_name_part(member_name(10));

mysql复制代码select account_no, balance from accounts where status = 1 and create_time between '2020-09-01 00:00:00' and '2020-09-30 23:59:59';

mysql复制代码select CONCAT( '# Time: ', DATE_FORMAT(start_time, '%y%m%d %H%i%s'), '\n', '# User@Host: ', user_host, '\n', '# Query_time: ', TIME_TO_SEC(query_time),  '  Lock_time: ', TIME_TO_SEC(lock_time), '  Rows_sent: ', rows_sent, '  Rows_examined: ', rows_examined, '\n', sql_text, ';' ) FROM mysql.slow_log where start_time between current_timestamp and date_add(CURRENT_TIMESTAMP,INTERVAL -5 MINUTE);

mysql复制代码| 2020-10-02 19:17:23 | w_mini_user[w_mini_user] @  [10.200.20.11] | 00:00:02   | 00:00:00  |         9 |        443117 | mini_user |              0 |         0 | 168387936 | select id,club_id,reason,status,type,created_time,invite_id,falg_admin,file_id from t_user_msg where 1 and (team_id in (3212) and app_id is not null) or (invite_id=12395 or applicant_id=12395) order by created_time desc limit 0,10; | 1219921665 |

mysql复制代码#原始SQL，频繁访问的接口，目前执行时间2s。
select id,team_id,reason,status,type,created_time,invite_id,falg_admin,file_id from t_user_msg where 1 and (team_id in (3212) and app_id is not null) or (invite_id=12395 or app_id=12395) order by created_time desc limit 0,10;

#执行计划
+----+-------------+--------------+-------+---------------------------------+------------+---------+------+------+-------------+
| id | select_type | table        | type  | possible_keys                   | key        | key_len | ref  | rows | Extra       |
+----+-------------+--------------+-------+---------------------------------+------------+---------+------+------+-------------+
|  1 | SIMPLE      | t_user_msg | index | invite_id,app_id,team_id | created_time | 5       | NULL |   10 | Using where |
+----+-------------+--------------+-------+---------------------------------+------------+---------+------+------+-------------+
1 row in set (0.00 sec)

sql复制代码select id, ……. from t_user_msg where 1 and  **(team_id in (3212) and app_id is not null)** order by created_time desc limit 0,10;

mysql复制代码| id | select_type | table        | type | possible_keys        | key     | key_len | ref   | rows | Extra                       |
+----+-------------+--------------+------+----------------------+---------+---------+-------+------+-----------------------------+
|  1 | SIMPLE      | t_user_msg | ref  | app_id,team_id | team_id | 8       | const |   30 | Using where; Using filesort |

sql复制代码select id, ……. from t_user_msg where 1 and  **(invite_id=12395 or app_id=12395)** order by created_time desc limit 0,10;

mysql复制代码| id | select_type | table        | type        | possible_keys           | key                     | key_len | ref  | rows | Extra                                                             |
+----+-------------+--------------+-------------+-------------------------+-------------------------+---------+------+------+-------------------------------------------------------------------+
|  1 | SIMPLE      | t_user_msg | index_merge | invite_id,app_id | invite_id,app_id | 9,9     | NULL |    2 | Using union(invite_id,app_id); Using where; Using filesort |

mysql复制代码mysql >select @@optimizer_switch;
| index_merge=on,index_merge_union=on,index_merge_sort_union=on,index_merge_intersection=on,

mysql复制代码| id | select_type | table        | type        | possible_keys                   | key                             | key_len | ref  | rows | Extra                                                                     |
+----+-------------+--------------+-------------+---------------------------------+---------------------------------+---------+------+------+---------------------------------------------------------------------------+
|  1 | SIMPLE      | t_user_msg | index_merge | invite_id,app_id,teadm_id | team_id,invite_id,app_id | 8,9,9   | NULL |   32 | Using union(team_id,invite_id,app_id); Using where; Using filesort |

sql复制代码select id, ……. from (
select id, ……. from t_user_msg where **1 and (club_id in (5821) and applicant_id is not null)**
        **union all** select id, ……. from t_user_msg where **1 and invitee_id='146737'**
        **union all** select id, ……. from  t_user_msg where **1 and app_id='146737'**
       ) as a order by created_time desc limit 0,10;

sql复制代码select id,team_id,reason,status,type,created_time,invite_id,falg_admin,file_id from t_user_msg where 1 and (team_id in (3212) and **IFNULL(app_id, 0) >0)**) or (invite_id=12395 or app_id=12395) order by created_time desc limit 0,10;

sql复制代码select id,team_id,reason,status,type,created_at,invite_id,falg_admin,file_id from t_user_msg where 1 and (team_id in (3212) and **app_id > 0)**) or (invite_id=12395 or app_id=12395) order by created_time desc limit 0,10;

python复制代码class Employee:

    outsource = False

    def __init__(self, department, name):
        self.department = department
        self.name = name

    @property
    def inservice(self):
        return self.department is not None

    def __repr__(self):
        return f"<Employee: {self.department}-{self.name}>"

employee = Employee('IT', 'bobo')

python复制代码>>> e1 = Employee('IT', 'bobo')
>>> e2 = Employee('HR', 'cici')
>>> e1.outsource, e2.outsource
(False, False)
>>> Employee.outsource = True
>>> e1.outsource, e2.outsource
>>> (True, True)

python复制代码>>> e1 = Employee('IT', 'bobo')
>>> e2 = Employee('HR', 'cici')
>>> e1.outsource, e2.outsource
(False, False)
>>> e1.outsource = True
>>> e1.outsource, e2.outsource
(True, False)

python复制代码>>> class S:
...     L = [1, 2]
...
>>> s1, s2 = S(), S()
>>> s1.L, s2.L
([1, 2], [1, 2])
>>> t1.L.append(3)
>>> t1.L, s2.L
([1, 2, 3], [1, 2, 3])

python复制代码>>> e = Employee('IT', 'bobo')
>>> e.__dict__
{'department': 'IT', 'name': 'bobo'}
>>> type(e.__dict__)
dict
>>> e.name is e.__dict__['name']
True
>>> e.__dict__['department'] = 'HR'
>>> e.department
'HR'

py复制代码>>> e.age = 30 # 并没有定义 age 属性
>>> e.age
30
>>> e.__dict__
{'department': 'IT', 'name': 'bobo', 'age': 30}
>>> del e.age
>>> e.__dict__
{'department': 'IT', 'name': 'd'}

python复制代码>>> def new_employee_from(d):
...     instance = object.__new__(Employee)
...     instance.__dict__.update(d)
...     return instance
...
>>> e1 = new_employee_from({'department': 'IT', 'name': 'bobo'})
>>> e1
<Employee: IT-bobo>
>>> state = e1.__dict__.copy()
>>> del e1
>>> e2 = new_employee_from(state)
>>> e2
>>> <Employee: IT-bobo>

python复制代码>>> e.__dict__[1] = 1
>>> e.__dict__
{'department': 'IT', 'name': 'bobo', 1: 1}

python复制代码>>> Employee.__dict__
mappingproxy({'__module__': '__main__',
              'outsource': True,
              '__init__': <function __main__.Employee.__init__(self, department, name)>,
              'inservice': <property at 0x108419ea0>,
              '__repr__': <function __main__.Employee.__repr__(self)>,
              '__str__': <function __main__.Employee.__str__(self)>,
              '__dict__': <attribute '__dict__' of 'Employee' objects>,
              '__weakref__': <attribute '__weakref__' of 'Employee' objects>,
              '__doc__': None}

>>> type(Employee.__dict__)
mappingproxy

python复制代码>>> Employee.__dict__['outsource'] = False
TypeError: 'mappingproxy' object does not support item assignment

python复制代码class Employee:
    # ...
    @staticmethod
    def soo():
        pass

    @classmethod
    def coo(cls):
        pass

    def foo(self):
        pass

python复制代码>>> Employee.__dict__
mappingproxy({'__module__': '__main__',
              'outsource': False,
              '__init__': <function __main__.Employee.__init__(self, department, name)>,
              '__repr__': <function __main__.Employee.__repr__(self)>,
              'inservice': <property at 0x108419ea0>,
              'soo': <staticmethod at 0x1066ce588>,
              'coo': <classmethod at 0x1066ce828>,
              'foo': <function __main__.Employee.foo(self)>,
              '__dict__': <attribute '__dict__' of 'Employee' objects>,
              '__weakref__': <attribute '__weakref__' of 'Employee' objects>,
              '__doc__': None})

python复制代码>>> class A:
...     pass
...
>>> class B:
...     pass
...
>>> class C(B):
...     pass
...
>>> class D(A, C):
...     pass
...
>>> D.mro()
[<class '__main__.D'>, <class '__main__.A'>, <class '__main__.C'>, <class '__main__.B'>, <class 'object'>]

python复制代码def get_attribute(obj, name):
    class_definition = obj.__class__

    descriptor = None
    for cls in class_definition.mro():
        if name in cls.__dict__:
            descriptor = cls.__dict__[name]
            break

    if hasattr(descriptor, '__set__'):
        return descriptor, 'data descriptor'

    if name in obj.__dict__:
        return obj.__dict__[name], 'instance attribute'

    if descriptor is not None:
        return descriptor, 'non-data descriptor'
    else:
        raise AttributeError

python复制代码>>> e = Employee('IT', 'bobo')
>>> get_attribute(e, 'outsource')
(False, 'non-data descriptor')
>>> e.outsource = True
>>> get_attribute(e, 'outsource')
(True, 'instance attribute')
>>> get_attribute(e, 'name')
('bobo', 'instance attribute')
>>> get_attribute(e, 'inservice')
(<property at 0x10c966d10>, 'data descriptor')
>>> get_attribute(e, 'foo')
(<function __main__.Employee.foo(self)>, 'non-data descriptor')

python复制代码>>> class Manager(Employee):
...     def __init__(self, *arg):
...         self.inservice = True
...         super().__init__(*arg)
...
>>> m = Manager("HR", "cici")
AttributeError: can't set attribute

python复制代码class Function:
    def __get__(self, obj, objtype=None):
        if obj is None:
            return self
        return types.MethodType(self, obj) # 将函数绑定为方法

python复制代码>>> Employee.coo
<bound method Employee.coo of <class '__main__.Employee'>>
>>> Employee.foo
<function __main__.Employee.foo(self)>
>>> e = Employee('IT', 'bobo')
>>> e.foo
<bound method Employee.foo of <Employee: IT-bobo>>

python复制代码>>> e.foo.__self__
<Employee: IT-bobo>
>>> e.foo.__self__.__class__
__main__.Employee

python复制代码>>> def f1(self):
...     if isinstance(self, type):
...         return self.outsource
...     return self.name
...
>>> bound_f1 = f1.__get__(e, Employee) # or bound_f1 = f1.__get__(e)
>>> bound_f1
<bound method f1 of <Employee: IT-bobo>>
>>> bound_f1.__self__
<Employee: IT-bobo>
>>> bound_f1()
'bobo'

python复制代码class Test:
    __slots__ = ('a', 'b')

    def __init__(self, a, b):
        self.a = a
        self.b = b

python复制代码>>> t = Test(1, 2)
>>> t.__dict__
AttributeError: 'Test' object has no attribute '__dict__'
>>> Test.__dict__
mappingproxy({'__module__': '__main__',
              '__slots__': ('a', 'b'),
              '__init__': <function __main__.Test.__init__(self, a, b)>,
              'a': <member 'a' of 'Test' objects>,
              'b': <member 'b' of 'Test' objects>,
              '__doc__': None})

python复制代码def __getattribute__(self, key):
    v = object.__getattribute__(self, key)
    if hasattr(v, '__get__'):
        return v.__get__(self)
    return v

python复制代码def calltracker(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        wrapper.calls += 1
        return func(*args, **kwargs)
    wrapper.calls = 0
    return wrapper

@calltracker
def f():
    return 'f called'

python复制代码>>> f.calls
0
>>> f()
'f called'
>>> f.calls
1

xml复制代码<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

java复制代码@SpringBootApplication
@EnableEurekaClient
public class GatewayApplication {
    public static void main(String[] args) {
        SpringApplication.run(GatewayApplication.class, args);
    }
}

yaml复制代码spring:
  application:
    name: apigateway
  cloud:
    gateway:
      routes:
      - id: open
        uri: lb://open
        predicates:
        - Path=/open/**
        filters:
        - StripPrefix= 1
      - id: system
        uri: lb://system
        predicates:
        - Path=/system/**
        filters:
        - StripPrefix= 1
server:
  port: 9999
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka
  instance:
    prefer-ip-address: true

java复制代码@Bean
public CorsWebFilter corsFilter() {
    CorsConfiguration config = new CorsConfiguration();
    config.addAllowedMethod("*");//支持所有方法
    config.addAllowedOrigin("*");//跨域处理 允许所有的域
    config.addAllowedHeader("*");//支持所有请求头

    UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource(new PathPatternParser());
    source.registerCorsConfiguration("/**", config);//匹配所有请求

    return new CorsWebFilter(source);
}

java复制代码@Component
public class IpFilter implements GlobalFilter, Ordered {

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();
        InetSocketAddress remoteAddress = request.getRemoteAddress();
        //TODO 设置ip白名单
        System.out.println("ip:"+remoteAddress.getHostName());
        return chain.filter(exchange);
    }
    @Override
    public int getOrder() {
        return 1;
    }
}

java复制代码@Component
public class UrlFilter implements GlobalFilter, Ordered {

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();
        String url = request.getURI().getPath();
        //TODO 拦截特定URL地址
        System.out.println("url:"+url);
        return chain.filter(exchange);
    }

    @Override
    public int getOrder() {
        return 2;
    }
}

xml复制代码<!--redis-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis-reactive</artifactId>
    <version>2.1.3.RELEASE</version>
</dependency>

java复制代码    //定义一个KeyResolver
    @Bean
    public KeyResolver ipKeyResolver() {
        return new KeyResolver() {
            @Override
            public Mono<String> resolve(ServerWebExchange exchange) {
                return Mono.just(exchange.getRequest().getRemoteAddress().getHostName());
            }
        };
    }

yaml复制代码spring:
  application:
    name: apigateway
  cloud:
    gateway:
      routes:
      - id: open
        uri: lb://open
        predicates:
        - Path=/open/**
        filters:
        - StripPrefix= 1
        - name: RequestRateLimiter #请求数限流 名字不能随便写 
          args:
            key-resolver: "#{@ipKeyResolver}"
            redis-rate-limiter.replenishRate: 1
            redis-rate-limiter.burstCapacity: 1
      - id: system
        uri: lb://system
        predicates:
        - Path=/system/**
        filters:
        - StripPrefix= 1
  # 配置Redis 127.0.0.1可以省略配置
  redis:
    host: 101.57.2.128
    port: 6379
server:
  port: 9999
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:100/eureka
  instance:
    prefer-ip-address: true

java复制代码@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {
    boolean required() default true;
}

java复制代码public enum ElementType {
    /** 类，接口（包括注解类型）或枚举的声明 */
    TYPE,

    /** 属性的声明 */
    FIELD,

    /** 方法的声明 */
    METHOD,

    /** 方法形式参数声明 */
    PARAMETER,

    /** 构造方法的声明 */
    CONSTRUCTOR,

    /** 局部变量声明 */
    LOCAL_VARIABLE,

    /** 注解类型声明 */
    ANNOTATION_TYPE,

    /** 包的声明 */
    PACKAGE
}

java复制代码// 可以作用在 构造方法、方法、方法形参、属性、注解类型 上
@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})

java复制代码public enum RetentionPolicy {
    /**
     * Annotations are to be discarded by the compiler.
     * （注解将被编译器忽略掉）
     */
    SOURCE,

    /**
     * Annotations are to be recorded in the class file by the compiler
     * but need not be retained by the VM at run time.  This is the default
     * behavior.
     * （注解将被编译器记录在class文件中，但在运行时不会被虚拟机保留，这是一个默认的行为）
     */
    CLASS,

    /**
     * Annotations are to be recorded in the class file by the compiler and
     * retained by the VM at run time, so they may be read reflectively.
     * （注解将被编译器记录在class文件中，而且在运行时会被虚拟机保留，因此它们能通过反射被读取到）
     * @see java.lang.reflect.AnnotatedElement
     */
    RUNTIME
}

json复制代码{
    #返回状态码
    code:integer,       
    #返回信息描述
    message:string,
    #返回数据值
    data:object
}

java复制代码/**
 * @author 【 木子雷 】 公众号
 * @Title: ResponseCode
 * @Description: 使用枚举类封装好的响应状态码及对应的响应消息
 * @date: 2019年8月23日 下午7:12:50
 */
public enum ResponseCode {

    SUCCESS(1200, "请求成功"),

    ERROR(1400, "请求失败");


    private Integer code;

    private String message;

    private ResponseCode(Integer code, String message) {
        this.code = code;
        this.message = message;
    }

    public Integer code() {
        return this.code;
    }

    public String message() {
        return this.message;
    }

}

java复制代码import com.alibaba.fastjson.JSONObject;
import java.io.Serializable;

/**
 * @author 【 木子雷 】 公众号
 * @Title: Response
 * @Description: 封装的统一的响应返回类
 * @date: 2019年8月23日 下午7:07:13
 */
@SuppressWarnings("serial")
public class Response<T> implements Serializable {

    /**
     * 响应数据
     */
    private T date;

    /**
     * 响应状态码
     */
    private Integer code;

    /**
     * 响应描述信息
     */
    private String message;

    public Response(T date, Integer code, String message) {
        super();
        this.date = date;
        this.code = code;
        this.message = message;
    }


    public T getDate() {
        return date;
    }

    public void setDate(T date) {
        this.date = date;
    }

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }


    @Override
    public String toString() {
        return JSONObject.toJSONString(this);
    }
}

java复制代码@GetMapping("/user/findAllUser")
public Response<List<User>> findAllUser() {
    logger.info("开始查询所有数据...");

    List<User> findAllUser = new ArrayList<>();
    findAllUser.add(new User("木子雷", 26));
    findAllUser.add(new User("公众号", 28));

    // 返回响应进行包装
    Response response = new Response(findAllUser, ResponseCode.SUCCESS.code(), ResponseCode.SUCCESS.message());

    logger.info("response: {} \n", response.toString());
    return response;
}

json复制代码{
    "code": 1200,
    "date": [
        {
            "age": 26,
            "name": "木子雷"
        },
        {
            "age": 28,
            "name": "公众号"
        }
    ],
    "message": "请求成功"
}

java复制代码/**
 * @author 【 木子雷 】 公众号
 * @PACKAGE_NAME: com.lyl.annotation
 * @ClassName: ResponseResult
 * @Description: 标记方法返回值需要进行包装的 自定义注解
 * @Date: 2020-11-10 10:38
 **/
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface ResponseResult {

}

java复制代码/**
 * @author 【 木子雷 】 公众号
 * @PACKAGE_NAME: com.lyl.interceptor
 * @ClassName: ResponseResultInterceptor
 * @Description: 拦截器：拦截请求，判断请求的方法或类上是否使用了自定义的@ResponseResult注解，
 *               并在请求内设置是否使用了自定义注解的标志位属性；
 * @Date: 2020-11-10 10:50
 **/
@Component
public class ResponseResultInterceptor implements HandlerInterceptor {

    /**
     * 标记位，标记请求的controller类或方法上使用了到了自定义注解，返回数据需要被包装
     */
    public static final String RESPONSE_ANNOTATION = "RESPONSE_ANNOTATION";

    /**
     * 请求预处理，判断是否使用了自定义注解
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        // 请求的接口方法
        if (handler instanceof HandlerMethod) {
            final HandlerMethod handlerMethod = (HandlerMethod) handler;
            final Class<?> clazz = handlerMethod.getBeanType();
            final Method method = handlerMethod.getMethod();
            // 判断是否在类对象上加了注解
            if (clazz.isAnnotationPresent(ResponseResult.class)) {
                // 在请求中设置需要进行响应包装的属性标志，在下面的ResponseBodyAdvice增强中进行处理
                request.setAttribute(RESPONSE_ANNOTATION, clazz.getAnnotation(ResponseResult.class));
            } else if (method.isAnnotationPresent(ResponseResult.class)) {
                // 在请求中设置需要进行响应包装的属性标志，在下面的ResponseBodyAdvice增强中进行处理
                request.setAttribute(RESPONSE_ANNOTATION, method.getAnnotation(ResponseResult.class));
            }
        }
        return true;
    }
}

java复制代码/**
 * @author 【 木子雷 】 公众号
 * @PACKAGE_NAME: com.lyl.interceptor
 * @ClassName: ResponseResultHandler
 * @Description: 对 返回响应 进行包装 的增强处理
 * @Date: 2020-11-10 13:49
 **/
@ControllerAdvice
public class ResponseResultHandler implements ResponseBodyAdvice<Object> {

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    /**
     * 标记位，标记请求的controller类或方法上使用了到了自定义注解，返回数据需要被包装
     */
    public static final String RESPONSE_ANNOTATION = "RESPONSE_ANNOTATION";

    /**
     * 请求中是否包含了 响应需要被包装的标记，如果没有，则直接返回，不需要重写返回体
     *
     * @param methodParameter
     * @param aClass
     * @return
     */
    @Override
    public boolean supports(MethodParameter methodParameter, Class<? extends HttpMessageConverter<?>> aClass) {
        ServletRequestAttributes ra = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest sr = (HttpServletRequest) ra.getRequest();
        // 查询是否需要进行响应包装的标志
        ResponseResult responseResult = (ResponseResult) sr.getAttribute(RESPONSE_ANNOTATION);
        return responseResult == null ? false : true;
    }


    /**
     * 对 响应体 进行包装; 除此之外还可以对响应体进行统一的加密、签名等
     *
     * @param responseBody  请求的接口方法执行后得到返回值(返回响应)
     */
    @Override
    public Object beforeBodyWrite(Object responseBody, MethodParameter methodParameter, MediaType mediaType, Class<? extends HttpMessageConverter<?>> aClass, ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse) {
        logger.info("返回响应 包装进行中。。。");
        Response response;
        // boolean类型时判断一些数据库新增、更新、删除的操作是否成功
        if (responseBody instanceof Boolean) {
            if ((Boolean) responseBody) {
                response = new Response(responseBody, ResponseCode.SUCCESS.code(), ResponseCode.SUCCESS.message());
            } else {
                response = new Response(responseBody, ResponseCode.ERROR.code(), ResponseCode.ERROR.message());
            }
        } else {
            // 判断像查询一些返回数据的情况，查询不到数据返回 null;
            if (null != responseBody) {
                response = new Response(responseBody, ResponseCode.SUCCESS.code(), ResponseCode.SUCCESS.message());
            } else {
                response = new Response(responseBody, ResponseCode.ERROR.code(), ResponseCode.ERROR.message());
            }
        }
        return response;
    }
}

java复制代码// 自定义注解用在了方法上
@ResponseResult
@GetMapping("/user/findAllUserByAnnotation")
public List<User> findAllUserByAnnotation() {
    logger.info("开始查询所有数据...");

    List<User> findAllUser = new ArrayList<>();
    findAllUser.add(new User("木子雷", 26));
    findAllUser.add(new User("公众号", 28));

    logger.info("使用 @ResponseResult 自定义注解进行响应的包装，使controller代码更加简介");
    return findAllUser;
}

java复制代码/**
 * @author 【 木子雷 】 公众号
 * @PACKAGE_NAME: com.lyl.annotation
 * @ClassName: GetDistributedLock
 * @Description: 获取redis分布式锁 注解
 * @Date: 2020-11-10 16:24
 **/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface GetDistributedLock {

    // 分布式锁 key
    String lockKey();

    // 分布式锁 value，默认为 lockValue
    String lockValue() default "lockValue";

    // 过期时间，默认为 300秒
    int expireTime() default 300;

}

java复制代码/**
 * @author: 【 木子雷 】 公众号
 * @PACKAGE_NAME: com.lyl.aop
 * @ClassName: DistributedLockAspect
 * @Description: 自定义注解结合AOP切面编程优雅的使用分布式锁
 * @Date: 2020-11-10 16:52
 **/
@Component
@Aspect
public class DistributedLockAspect {

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    @Autowired
    RedisService redisService;


    /**
     * Around 环绕增强通知
     *
     * @param joinPoint 连接点，所有方法都属于连接点；但是当某些方法上使用了@GetDistributedLock自定义注解时，
     *                  则其将连接点变为了切点；然后在切点上织入额外的增强处理；切点和其相应的增强处理构成了切面Aspect 。
     */
    @Around(value = "@annotation(com.lyl.annotation.GetDistributedLock)")
    public Boolean handlerDistributedLock(ProceedingJoinPoint joinPoint) {
        // 通过反射获取自定义注解对象
        GetDistributedLock getDistributedLock = ((MethodSignature) joinPoint.getSignature())
                .getMethod().getAnnotation(GetDistributedLock.class);

        // 获取自定义注解对象中的属性值
        String lockKey = getDistributedLock.lockKey();
        String LockValue = getDistributedLock.lockValue();
        int expireTime = getDistributedLock.expireTime();

        if (redisService.tryGetDistributedLock(lockKey, LockValue, expireTime)) {
            // 获取分布式锁成功后，继续执行业务逻辑
            try {
                return (boolean) joinPoint.proceed();
            } catch (Throwable throwable) {
                logger.error("业务逻辑执行失败。", throwable);
            } finally {
                // 最终保证分布式锁的释放
                redisService.releaseDistributedLock(lockKey, LockValue);
            }
        }
        return false;
    }

}

java复制代码// 自定义注解的使用
@GetDistributedLock(lockKey = "userLock")
@GetMapping("/user/getDistributedLock")
public boolean getUserDistributedLock() {
    logger.info("获取分布式锁...");
    // 写具体的业务逻辑

    return true;
}

java复制代码/**
 * @Author: 【 木子雷 】 公众号
 * @PACKAGE_NAME: com.lyl.annotation
 * @ClassName: PrintLog
 * @Description: 自定义注解实现日志打印
 * @Date: 2020-11-10 18:05
 **/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface PrintLog {

}

java复制代码/**
 * @author: 【 木子雷 】 公众号
 * @PACKAGE_NAME: com.lyl.aop
 * @ClassName: PrintLogAspect
 * @Description: 自定义注解结合AOP切面编程优雅的实现日志打印
 * @Date: 2020-11-10 18:11
 **/
@Component
@Aspect
public class PrintLogAspect {

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    /**
     *  Around 环绕增强通知
     *
     * @param joinPoint 连接点，所有方法都属于连接点；但是当某些方法上使用了@PrintLog自定义注解时，
     *                  则其将连接点变为了切点；然后在切点上织入额外的增强处理；切点和其相应的增强处理构成了切面Aspect 。
     */
    @Around(value = "@annotation(com.lyl.annotation.PrintLog)")
    public Object handlerPrintLog(ProceedingJoinPoint joinPoint) {
        // 获取方法的名称
        String methodName = joinPoint.getSignature().getName();
        // 获取方法入参
        Object[] param = joinPoint.getArgs();

        StringBuilder sb = new StringBuilder();
        for (Object o : param) {
            sb.append(o + "; ");
        }
        logger.info("进入《{}》方法, 参数为: {}", methodName, sb.toString());

        Object object = null;
        // 继续执行方法
        try {
            object = joinPoint.proceed();

        } catch (Throwable throwable) {
            logger.error("打印日志处理error。。", throwable);
        }
        logger.info("{} 方法执行结束。。", methodName);
        return object;
    }

}

java复制代码@PrintLog
@GetMapping(value = "/user/findUserNameById/{id}", produces = "application/json;charset=utf-8")
public String findUserNameById(@PathVariable("id") int id) {
    // 模拟根据id查询用户名
    String userName = "木子雷 公众号";
    return userName;
}

java复制代码进入《findUserNameById》方法, 参数为: 66; 
findUserNameById 方法执行结束。。